case class Append[+F[_], +O](head: HaltEmitOrAwait[F, O], stack: Vector[(Cause) ⇒ Trampoline[Process[F, O]]]) extends Process[F, O] with Product with Serializable

The Append constructor instructs the driver to continue with evaluation of first step found in tail Vector.

Instead of this constructor please use:

Process.append

Source
Process.scala
Linear Supertypes
Serializable, Serializable, Product, Equals, Process[F, O], TeeOps[F, O], Process1Ops[F, O], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Append
  2. Serializable
  3. Serializable
  4. Product
  5. Equals
  6. Process
  7. TeeOps
  8. Process1Ops
  9. AnyRef
  10. Any
Implicitly
  1. by SourceSyntax
  2. by toProcess1Syntax
  3. by toWyeSyntax
  4. by toWriterTaskSyntax
  5. by toTeeSyntax
  6. by toSinkTaskSyntax
  7. by SourceSyntax
  8. by toWyeSyntax
  9. by toWriterTaskSyntax
  10. by toTeeSyntax
  11. by toSinkTaskSyntax
  12. by toProcess1Syntax
  13. by any2stringadd
  14. by StringFormat
  15. by Ensuring
  16. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Append(head: HaltEmitOrAwait[F, O], stack: Vector[(Cause) ⇒ Trampoline[Process[F, O]]])

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def +(other: String): String
    Implicit
    This member is added by an implicit conversion from Append[F, O] to any2stringadd[Append[F, O]] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  4. final def ++[F2[x] >: F[x], O2 >: O](p2: ⇒ Process[F2, O2]): Process[F2, O2]

    Alias for append

    Alias for append

    Definition Classes
    Process
  5. def ->[B](y: B): (Append[F, O], B)
    Implicit
    This member is added by an implicit conversion from Append[F, O] to ArrowAssoc[Append[F, O]] performed by method ArrowAssoc in scala.Predef. This conversion will take place only if F is a subclass of Is with Task (F <: Is with Task) and at the same time O is a subclass of (Nothing) ⇒ Nothing with \/[Nothing, Nothing] (O <: (Nothing) ⇒ Nothing with \/[Nothing, Nothing]).
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. final def append[F2[x] >: F[x], O2 >: O](p2: ⇒ Process[F2, O2]): Process[F2, O2]

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

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

    Definition Classes
    Process
  8. final def asFinalizer: Process[F, O]

    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
  9. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  10. final def attempt[F2[x] >: F[x], O2](f: (Throwable) ⇒ Process[F2, O2] = (t: Throwable) => emit(t)): Process[F2, \/[O2, O]]

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

    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
  11. def awaitOption: Process[F, Option[O]]

    Alias for this |> process1.awaitOption.

    Alias for this |> process1.awaitOption.

    Definition Classes
    Process1Ops
  12. def buffer(n: Int): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  13. def bufferAll: Process[F, O]

    Alias for this |> process1.bufferAll.

    Alias for this |> process1.bufferAll.

    Definition Classes
    Process1Ops
  14. def bufferBy(f: (O) ⇒ Boolean): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  15. final def causedBy(cause: Cause): Process[F, O]

    Attached cause when this Process terminates.

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

    Definition Classes
    Process
  16. def chunk(n: Int): Process[F, Vector[O]]

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

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

    Definition Classes
    Process1Ops
  17. def chunkAll: Process[F, Vector[O]]

    Alias for this |> process1.chunkAll.

    Alias for this |> process1.chunkAll.

    Definition Classes
    Process1Ops
  18. def chunkBy(f: (O) ⇒ Boolean): Process[F, Vector[O]]

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

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

    Definition Classes
    Process1Ops
  19. def chunkBy2(f: (O, O) ⇒ Boolean): Process[F, Vector[O]]

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

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

    Definition Classes
    Process1Ops
  20. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  21. def collect[O2](pf: PartialFunction[O, O2]): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  22. def collectFirst[O2](pf: PartialFunction[O, O2]): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  23. def delete(f: (O) ⇒ Boolean): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  24. final def disconnect(cause: EarlyCause): Process0[O]

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

    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
  25. def distinctConsecutive[O2 >: O](implicit O2: Equal[O2]): Process[F, O2]

    Alias for this |> process1.distinctConsecutive.

    Alias for this |> process1.distinctConsecutive.

    Definition Classes
    Process1Ops
  26. def distinctConsecutiveBy[B](f: (O) ⇒ B)(implicit arg0: Equal[B]): Process[F, O]

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

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

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

    Ignore all outputs of this Process.

    Ignore all outputs of this Process.

    Definition Classes
    Process
  28. def drop(n: Int): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  29. def dropLast: Process[F, O]

    Alias for this |> process1.dropLast.

    Alias for this |> process1.dropLast.

    Definition Classes
    Process1Ops
  30. def dropLastIf(p: (O) ⇒ Boolean): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  31. def dropRight(n: Int): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  32. def dropWhile(f: (O) ⇒ Boolean): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  33. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    Definition Classes
    WyeOps
  34. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    Definition Classes
    WyeOps
  35. def ensuring(cond: (Append[F, O]) ⇒ Boolean, msg: ⇒ Any): Append[F, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to Ensuring[Append[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  36. def ensuring(cond: (Append[F, O]) ⇒ Boolean): Append[F, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to Ensuring[Append[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  37. def ensuring(cond: Boolean, msg: ⇒ Any): Append[F, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to Ensuring[Append[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  38. def ensuring(cond: Boolean): Append[F, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to Ensuring[Append[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  39. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  40. def evalMap[F2[x] >: F[x], O2](f: (O) ⇒ F2[O2]): Process[F2, O2]

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

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

    Definition Classes
    Process
  41. def exists(f: (O) ⇒ Boolean): Process[F, Boolean]

    Alias for this |> process1.exists(f)

    Alias for this |> process1.exists(f)

    Definition Classes
    Process1Ops
  42. def extend[F2[x] >: F[x], O2](f: (Process[F, O]) ⇒ Process[F2, O2]): Process[F2, O2]

    Helper to modify the head and appended processes

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

    Alias for append

    Alias for append

    Definition Classes
    Process
  44. def filter(f: (O) ⇒ Boolean): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  45. def filterBy2(f: (O, O) ⇒ Boolean): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  46. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  47. def find(f: (O) ⇒ Boolean): Process[F, O]

    Alias for this |> process1.find(f)

    Alias for this |> process1.find(f)

    Definition Classes
    Process1Ops
  48. final def flatMap[F2[x] >: F[x], O2](f: (O) ⇒ Process[F2, O2]): Process[F2, O2]

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

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

    Definition Classes
    Process
  49. def fold[B](b: B)(f: (B, O) ⇒ B): Process[F, B]

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

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

    Definition Classes
    Process1Ops
  50. def fold1[O2 >: O](f: (O2, O2) ⇒ O2): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  51. def fold1Map[M](f: (O) ⇒ M)(implicit M: Monoid[M]): Process[F, M]

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

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

    Definition Classes
    Process1Ops
  52. def fold1Monoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

    Alias for this |> process1.fold1Monoid(M)

    Alias for this |> process1.fold1Monoid(M)

    Definition Classes
    Process1Ops
  53. def foldMap[M](f: (O) ⇒ M)(implicit M: Monoid[M]): Process[F, M]

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

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

    Definition Classes
    Process1Ops
  54. def foldMonoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

    Alias for this |> process1.foldMonoid(M)

    Alias for this |> process1.foldMonoid(M)

    Definition Classes
    Process1Ops
  55. def foldSemigroup[O2 >: O](implicit M: Semigroup[O2]): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  56. def forall(f: (O) ⇒ Boolean): Process[F, Boolean]

    Alias for this |> process1.forall(f)

    Alias for this |> process1.forall(f)

    Definition Classes
    Process1Ops
  57. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from Append[F, O] to StringFormat[Append[F, O]] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  58. def gatherMap[F2[x] >: F[x], O2](bufSize: Int)(f: (O) ⇒ F2[O2])(implicit F: Nondeterminism[F2]): Process[F2, O2]

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

    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
  59. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  60. def handle[F2[x] >: F[x], O2](f: PartialFunction[Throwable, Process[F2, O2]])(implicit F: Catchable[F2]): Process[F2, O2]

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

    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
  61. val head: HaltEmitOrAwait[F, O]
  62. def interleave[F2[x] >: F[x], O2 >: O](p2: Process[F2, O2]): Process[F2, O2]

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

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

    Definition Classes
    TeeOps
  63. def intersperse[O2 >: O](sep: O2): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  64. final def isHalt: Boolean

    Returns true, if this process is halted

    Returns true, if this process is halted

    Definition Classes
    Process
  65. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  66. final def kill: Process[F, Nothing]

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

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

    Definition Classes
    Process
  67. def last: Process[F, O]

    Alias for this |> process1.last.

    Alias for this |> process1.last.

    Definition Classes
    Process1Ops
  68. def lastOr[O2 >: O](o: ⇒ O2): Process[F, O2]

    Alias for this |> process1.last.

    Alias for this |> process1.last.

    Definition Classes
    Process1Ops
  69. final def map[O2](f: (O) ⇒ O2): Process[F, O2]

    Transforms the output values of this Process using f.

    Transforms the output values of this Process using f.

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

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

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

    Definition Classes
    Process1Ops
  71. def maximum[O2 >: O](implicit O2: Order[O2]): Process[F, O2]

    Alias for this |> process1.maximum.

    Alias for this |> process1.maximum.

    Definition Classes
    Process1Ops
  72. def maximumBy[B](f: (O) ⇒ B)(implicit arg0: Order[B]): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  73. def maximumOf[B](f: (O) ⇒ B)(implicit arg0: Order[B]): Process[F, B]

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

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

    Definition Classes
    Process1Ops
  74. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    Definition Classes
    WyeOps
  75. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    Definition Classes
    WyeOps
  76. def minimum[O2 >: O](implicit O2: Order[O2]): Process[F, O2]

    Alias for this |> process1.minimum.

    Alias for this |> process1.minimum.

    Definition Classes
    Process1Ops
  77. def minimumBy[B](f: (O) ⇒ B)(implicit arg0: Order[B]): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  78. def minimumOf[B](f: (O) ⇒ B)(implicit arg0: Order[B]): Process[F, B]

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

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

    Definition Classes
    Process1Ops
  79. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  80. final def notify(): Unit
    Definition Classes
    AnyRef
  81. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  82. 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
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    Definition Classes
    WriterTaskSyntax
  83. 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
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    Definition Classes
    WriterTaskSyntax
  84. 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
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    Definition Classes
    WriterTaskSyntax
  85. 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
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    Definition Classes
    WriterTaskSyntax
  86. final def onComplete[F2[x] >: F[x], O2 >: O](p2: ⇒ Process[F2, O2]): Process[F2, O2]

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

    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
  87. final def onFailure[F2[x] >: F[x], O2 >: O](f: (Throwable) ⇒ Process[F2, O2]): Process[F2, O2]

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

    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
  88. final def onHalt[F2[x] >: F[x], O2 >: O](f: (Cause) ⇒ Process[F2, O2]): Process[F2, O2]

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

    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
  89. final def onKill[F2[x] >: F[x], O2 >: O](p: ⇒ Process[F2, O2]): Process[F2, O2]

    Attach supplied process only if process has been killed.

    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
  90. def once: Process[F, O]

    Alias for this |> Process.await1.

    Alias for this |> Process.await1.

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

    Like attempt, but accepts a partial function.

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

    Definition Classes
    Process
  92. final def pipe[O2](p1: Process1[O, O2]): Process[F, 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
  93. def prefixSums[O2 >: O](implicit N: Numeric[O2]): Process[F, O2]

    Alias for this |> process1.prefixSums

    Alias for this |> process1.prefixSums

    Definition Classes
    Process1Ops
  94. def prepend[O2 >: O](os: Seq[O2]): Process[F, 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
  95. def reduce[O2 >: O](f: (O2, O2) ⇒ O2): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  96. def reduceMap[M](f: (O) ⇒ M)(implicit M: Semigroup[M]): Process[F, M]

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

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

    Definition Classes
    Process1Ops
  97. def reduceMonoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  98. def reduceSemigroup[O2 >: O](implicit M: Semigroup[O2]): Process[F, O2]

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

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

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

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

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

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

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

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

    Definition Classes
    Process1Ops
  101. final def repeat: Process[F, O]

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

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

    Definition Classes
    Process
  102. final def run[F2[x] >: F[x]](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
  103. final def runFoldMap[F2[x] >: F[x], B](f: (O) ⇒ B)(implicit F: Monad[F2], C: Catchable[F2], B: Monoid[B]): F2[B]

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

    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
  104. final def runLast[F2[x] >: F[x], O2 >: O](implicit F: Monad[F2], C: Catchable[F2]): F2[Option[O2]]

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

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

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

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

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

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

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

    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
  107. def scan[B](b: B)(f: (B, O) ⇒ B): Process[F, B]

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

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

    Definition Classes
    Process1Ops
  108. def scan1[O2 >: O](f: (O2, O2) ⇒ O2): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  109. def scan1Map[M](f: (O) ⇒ M)(implicit M: Semigroup[M]): Process[F, M]

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

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

    Definition Classes
    Process1Ops
  110. def scan1Monoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  111. def scanMap[M](f: (O) ⇒ M)(implicit M: Monoid[M]): Process[F, M]

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

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

    Definition Classes
    Process1Ops
  112. def scanMonoid[O2 >: O](implicit M: Monoid[O2]): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  113. def scanSemigroup[O2 >: O](implicit M: Semigroup[O2]): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  114. def shiftRight[O2 >: O](head: O2*): Process[F, O2]

    Alias for this |> process1.shiftRight(head)

    Alias for this |> process1.shiftRight(head)

    Definition Classes
    Process1Ops
  115. def sleepUntil[F2[x] >: F[x], O2 >: O](awaken: Process[F2, Boolean]): Process[F2, O2]

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

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

    Definition Classes
    TeeOps
  116. def sliding(n: Int): Process[F, Vector[O]]

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

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

    Definition Classes
    Process1Ops
  117. def split(f: (O) ⇒ Boolean): Process[F, Vector[O]]

    Alias for this |> process1.split(f)

    Alias for this |> process1.split(f)

    Definition Classes
    Process1Ops
  118. def splitOn[P >: O](p: P)(implicit P: Equal[P]): Process[F, Vector[P]]

    Alias for this |> process1.splitOn(p)

    Alias for this |> process1.splitOn(p)

    Definition Classes
    Process1Ops
  119. def splitWith(f: (O) ⇒ Boolean): Process[F, Vector[O]]

    Alias for this |> process1.splitWith(f)

    Alias for this |> process1.splitWith(f)

    Definition Classes
    Process1Ops
  120. val stack: Vector[(Cause) ⇒ Trampoline[Process[F, O]]]
  121. def stateScan[S, B](init: S)(f: (O) ⇒ State[S, B]): Process[F, B]

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

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

    Definition Classes
    Process1Ops
  122. final def step: HaltOrStep[F, O]

    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
  123. def sum[O2 >: O](implicit N: Numeric[O2]): Process[F, O2]

    Alias for this |> process1.sum

    Alias for this |> process1.sum

    Definition Classes
    Process1Ops
  124. final def suspendStep: Process0[HaltOrStep[F, O]]

    p.suspendStep propagates exceptions to p.

    p.suspendStep propagates exceptions to p.

    Definition Classes
    Process
  125. final def swallowKill: Process[F, O]

    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
  126. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  127. def tail: Process[F, O]

    Alias for this |> process1.tail.

    Alias for this |> process1.tail.

    Definition Classes
    Process1Ops
  128. def take(n: Int): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  129. def takeRight(n: Int): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  130. def takeThrough(f: (O) ⇒ Boolean): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  131. def takeWhile(f: (O) ⇒ Boolean): Process[F, O]

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

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

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

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

    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
  133. def terminated: Process[F, Option[O]]

    Alias for this |> process1.terminated.

    Alias for this |> process1.terminated.

    Definition Classes
    Process1Ops
  134. 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
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    Definition Classes
    WriterTaskSyntax
  135. 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
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    Definition Classes
    WriterTaskSyntax
  136. 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
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    Definition Classes
    WriterTaskSyntax
  137. 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
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    Definition Classes
    WriterTaskSyntax
  138. def translate[G[_]](f: ~>[F, G]): Process[G, O]

    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
  139. final def trim: Process[F, O]

    Remove any leading emitted values from this Process.

    Remove any leading emitted values from this Process.

    Definition Classes
    Process
    Annotations
    @tailrec()
  140. final def uncons[F2[x] >: F[x], O2 >: O](implicit F: Monad[F2], C: Catchable[F2]): F2[(O2, Process[F2, O2])]
    Definition Classes
    Process
  141. final def unconsOption[F2[x] >: F[x], O2 >: O](implicit F: Monad[F2], C: Catchable[F2]): F2[Option[(O2, Process[F2, O2])]]
    Definition Classes
    Process
  142. final def unemit: (Seq[O], Process[F, O])

    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
  143. def until[F2[x] >: F[x], O2 >: O](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
  144. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  145. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  146. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  147. def when[F2[x] >: F[x], O2 >: O](condition: Process[F2, Boolean]): Process[F2, O2]

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

    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
  148. def zip[F2[x] >: F[x], O2](p2: Process[F2, O2]): Process[F2, (O, O2)]

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

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

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

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

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

    Definition Classes
    TeeOps
  150. def zipWithIndex[N](implicit arg0: Numeric[N]): Process[F, (O, N)]

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

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

    Definition Classes
    Process1Ops
  151. def zipWithIndex: Process[F, (O, Int)]

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

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

    Definition Classes
    Process1Ops
  152. def zipWithNext: Process[F, (O, Option[O])]

    Alias for this |> process1.zipWithNext.

    Alias for this |> process1.zipWithNext.

    Definition Classes
    Process1Ops
  153. def zipWithPrevious: Process[F, (Option[O], O)]

    Alias for this |> process1.zipWithPrevious.

    Alias for this |> process1.zipWithPrevious.

    Definition Classes
    Process1Ops
  154. def zipWithPreviousAndNext: Process[F, (Option[O], O, Option[O])]

    Alias for this |> process1.zipWithPreviousAndNext.

    Alias for this |> process1.zipWithPreviousAndNext.

    Definition Classes
    Process1Ops
  155. def zipWithScan[B](z: B)(next: (O, B) ⇒ B): Process[F, (O, B)]

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

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

    Definition Classes
    Process1Ops
  156. def zipWithScan1[B](z: B)(next: (O, B) ⇒ B): Process[F, (O, B)]

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

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

    Definition Classes
    Process1Ops
  157. def zipWithState[B](z: B)(next: (O, B) ⇒ B): Process[F, (O, B)]

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

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

    Definition Classes
    Process1Ops
  158. final def |>[O2](p2: Process1[O, O2]): Process[F, O2]

    Operator alias for pipe.

    Operator alias for pipe.

    Definition Classes
    Process
  159. def →[B](y: B): (Append[F, O], B)
    Implicit
    This member is added by an implicit conversion from Append[F, O] to ArrowAssoc[Append[F, O]] performed by method ArrowAssoc in scala.Predef. This conversion will take place only if F is a subclass of Is with Task (F <: Is with Task) and at the same time O is a subclass of (Nothing) ⇒ Nothing with \/[Nothing, Nothing] (O <: (Nothing) ⇒ Nothing with \/[Nothing, Nothing]).
    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
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).contramap(f)
    Definition Classes
    Process1Syntax
  10. def contramap[I0](f: (I0) ⇒ Any): Process1[I0, O]

    Transform the input of this Process1.

    Transform the input of this Process1.

    Implicit
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).contramap(f)
    Definition Classes
    Process1Syntax
  11. 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: WyeSyntax[Any, Any, O]).contramapL(f)
    Definition Classes
    WyeSyntax
  12. 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
    This member is added by an implicit conversion from Append[F, O] to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of T (F <: T).
    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:
    (append: TeeSyntax[Any, Any, O]).contramapL(f)
    Definition Classes
    TeeSyntax
  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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of T (F <: T).
    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:
    (append: TeeSyntax[Any, Any, O]).contramapL(f)
    Definition Classes
    TeeSyntax
  15. 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: WyeSyntax[Any, Any, O]).contramapR(f)
    Definition Classes
    WyeSyntax
  16. 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
    This member is added by an implicit conversion from Append[F, O] to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of T (F <: T).
    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:
    (append: TeeSyntax[Any, Any, O]).contramapR(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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: 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
    This member is added by an implicit conversion from Append[F, O] to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of T (F <: T).
    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:
    (append: TeeSyntax[Any, Any, O]).contramapR(f)
    Definition Classes
    TeeSyntax
  19. 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: WyeSyntax[Any, Any, O]).detach1L
    Definition Classes
    WyeSyntax
  20. 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: WyeSyntax[Any, Any, O]).detach1L
    Definition Classes
    WyeSyntax
  21. 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: WyeSyntax[Any, Any, O]).detach1R
    Definition Classes
    WyeSyntax
  22. 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
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: WyeSyntax[Any, Any, O]).detach1R
    Definition Classes
    WyeSyntax
  23. def feed1(i: Any): Process1[Any, O]

    Feed a single input to this Process1.

    Feed a single input to this Process1.

    Implicit
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).feed1(i)
    Definition Classes
    Process1Syntax
  24. def feed1(i: Any): Process1[Any, O]

    Feed a single input to this Process1.

    Feed a single input to this Process1.

    Implicit
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).feed1(i)
    Definition Classes
    Process1Syntax
  25. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).forwardFill(S)
    Definition Classes
    SourceSyntax
  26. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).forwardFill(S)
    Definition Classes
    SourceSyntax
  27. 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
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).liftL
    Definition Classes
    Process1Syntax
  28. 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
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).liftL
    Definition Classes
    Process1Syntax
  29. 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
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).liftR
    Definition Classes
    Process1Syntax
  30. 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
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).liftR
    Definition Classes
    Process1Syntax
  31. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).observeThrough(ch)
    Definition Classes
    SourceSyntax
  32. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).observeThrough(ch)
    Definition Classes
    SourceSyntax
  33. 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
    This member is added by an implicit conversion from Append[F, O] to SinkTaskSyntax[Any] performed by method toSinkTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of (Any) ⇒ Task[Unit] (O <: (Any) ⇒ Task[Unit]).
    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:
    (append: SinkTaskSyntax[Any]).pipeIn(p1)
    Definition Classes
    SinkTaskSyntax
  34. 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
    This member is added by an implicit conversion from Append[F, O] to SinkTaskSyntax[Any] performed by method toSinkTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of (Any) ⇒ Task[Unit] (O <: (Any) ⇒ Task[Unit]).
    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:
    (append: SinkTaskSyntax[Any]).pipeIn(p1)
    Definition Classes
    SinkTaskSyntax
  35. val self: Process[Task, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).self
    Definition Classes
    SourceSyntax → WyeOps
  36. val self: Process1[Any, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).self
    Definition Classes
    Process1Syntax
  37. val self: Wye[Any, Any, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: WyeSyntax[Any, Any, O]).self
    Definition Classes
    WyeSyntax
  38. val self: Writer[Task, W, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    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:
    (append: WriterTaskSyntax[W, O]).self
    Definition Classes
    WriterTaskSyntax
  39. val self: Tee[Any, Any, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of T (F <: T).
    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:
    (append: TeeSyntax[Any, Any, O]).self
    Definition Classes
    TeeSyntax
  40. val self: Sink[Task, Any]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to SinkTaskSyntax[Any] performed by method toSinkTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of (Any) ⇒ Task[Unit] (O <: (Any) ⇒ Task[Unit]).
    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:
    (append: SinkTaskSyntax[Any]).self
    Definition Classes
    SinkTaskSyntax
  41. val self: Process[Task, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).self
    Definition Classes
    SourceSyntax → WyeOps
  42. val self: Wye[Any, Any, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to WyeSyntax[Any, Any, O] performed by method toWyeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Y (F <: Y).
    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:
    (append: WyeSyntax[Any, Any, O]).self
    Definition Classes
    WyeSyntax
  43. val self: Writer[Task, W, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to WriterTaskSyntax[W, O] performed by method toWriterTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of \/[W, O] (O <: \/[W, O]).
    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:
    (append: WriterTaskSyntax[W, O]).self
    Definition Classes
    WriterTaskSyntax
  44. val self: Tee[Any, Any, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to TeeSyntax[Any, Any, O] performed by method toTeeSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of T (F <: T).
    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:
    (append: TeeSyntax[Any, Any, O]).self
    Definition Classes
    TeeSyntax
  45. val self: Sink[Task, Any]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to SinkTaskSyntax[Any] performed by method toSinkTaskSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task) and at the same time O is a subclass of (Any) ⇒ Task[Unit] (O <: (Any) ⇒ Task[Unit]).
    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:
    (append: SinkTaskSyntax[Any]).self
    Definition Classes
    SinkTaskSyntax
  46. val self: Process1[Any, O]
    Implicit
    This member is added by an implicit conversion from Append[F, O] to Process1Syntax[Any, O] performed by method toProcess1Syntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Is (F <: Is).
    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:
    (append: Process1Syntax[Any, O]).self
    Definition Classes
    Process1Syntax
  47. def toSignal(implicit S: Strategy): Signal[O]

    converts process to signal *

    converts process to signal *

    Implicit
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).toSignal(S)
    Definition Classes
    SourceSyntax
  48. def toSignal(implicit S: Strategy): Signal[O]

    converts process to signal *

    converts process to signal *

    Implicit
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).toSignal(S)
    Definition Classes
    SourceSyntax
  49. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).wye(p2)(y)(S)
    Definition Classes
    WyeOps
  50. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).wye(p2)(y)(S)
    Definition Classes
    WyeOps
  51. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).yip(p2)(S)
    Definition Classes
    WyeOps
  52. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).yip(p2)(S)
    Definition Classes
    WyeOps
  53. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).yipWith(p2)(f)(S)
    Definition Classes
    WyeOps
  54. 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
    This member is added by an implicit conversion from Append[F, O] to SourceSyntax[O] performed by method SourceSyntax in scalaz.stream.Process. This conversion will take place only if F is a subclass of Task (F <: Task).
    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:
    (append: SourceSyntax[O]).yipWith(p2)(f)(S)
    Definition Classes
    WyeOps

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Process[F, O]

Inherited from TeeOps[F, O]

Inherited from Process1Ops[F, O]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion SourceSyntax from Append[F, O] to SourceSyntax[O]

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

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

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

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

Inherited by implicit conversion toSinkTaskSyntax from Append[F, O] to SinkTaskSyntax[Any]

Inherited by implicit conversion SourceSyntax from Append[F, O] to SourceSyntax[O]

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

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

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

Inherited by implicit conversion toSinkTaskSyntax from Append[F, O] to SinkTaskSyntax[Any]

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

Inherited by implicit conversion any2stringadd from Append[F, O] to any2stringadd[Append[F, O]]

Inherited by implicit conversion StringFormat from Append[F, O] to StringFormat[Append[F, O]]

Inherited by implicit conversion Ensuring from Append[F, O] to Ensuring[Append[F, O]]

Inherited by implicit conversion ArrowAssoc from Append[F, O] to ArrowAssoc[Append[F, O]]

Ungrouped