sealed trait Process[+F[_], +O] extends Process1Ops[F, O] with TeeOps[F, O]

An effectful stream of O values. In between emitting values a Process may request evaluation of F effects. A Process[Nothing,A] is a pure Process with no effects. A Process[Task,A] may have Task effects. A Process halts due to some Cause, generally End (indicating normal termination) or Error(t) for some t: Throwable indicating abnormal termination due to some uncaught error.

Source
Process.scala
Linear Supertypes
TeeOps[F, O], Process1Ops[F, O], AnyRef, Any
Known Subclasses
Append, Await, Emit, EmitOrAwait, Halt, HaltEmitOrAwait
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Process
  2. TeeOps
  3. Process1Ops
  4. AnyRef
  5. Any
Implicitly
  1. by SourceSyntax
  2. by toProcess1Syntax
  3. by toWyeSyntax
  4. by toWriterTaskSyntax
  5. by toTeeSyntax
  6. by toSinkTaskSyntax
  7. by any2stringadd
  8. by StringFormat
  9. by Ensuring
  10. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

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 Process[F, O] to any2stringadd[Process[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

  5. def ->[B](y: B): (Process[F, O], B)
    Implicit
    This member is added by an implicit conversion from Process[F, O] to ArrowAssoc[Process[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.

  8. 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 Process[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).
    Definition Classes
    Process1Syntax
  9. 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 Process[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).
    Definition Classes
    WyeSyntax
  10. 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.

  11. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  12. 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 Process[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).
    Definition Classes
    WyeSyntax
  13. 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 Process[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).
    Definition Classes
    WyeSyntax
  14. 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.

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

    Alias for this |> process1.awaitOption.

    Alias for this |> process1.awaitOption.

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

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

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

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

    Alias for this |> process1.bufferAll.

    Alias for this |> process1.bufferAll.

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

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

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

    Definition Classes
    Process1Ops
  19. 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.

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

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

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

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

    Alias for this |> process1.chunkAll.

    Alias for this |> process1.chunkAll.

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

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

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

    Definition Classes
    Process1Ops
  23. 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
  24. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  25. 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
  26. 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
  27. 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 Process[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).
    Definition Classes
    Process1Syntax
  28. 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 Process[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).
    Definition Classes
    WyeSyntax
  29. 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 Process[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).
    Definition Classes
    TeeSyntax
  30. 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 Process[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).
    Definition Classes
    WyeSyntax
  31. 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 Process[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).
    Definition Classes
    TeeSyntax
  32. def delete(f: (O) ⇒ Boolean): Process[F, O]

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

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

    Definition Classes
    Process1Ops
  33. 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 Process[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).
    Definition Classes
    WyeSyntax
  34. 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 Process[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).
    Definition Classes
    WyeSyntax
  35. 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

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

    Alias for this |> process1.distinctConsecutive.

    Alias for this |> process1.distinctConsecutive.

    Definition Classes
    Process1Ops
  37. 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
  38. final def drain: Process[F, Nothing]

    Ignore all outputs of this Process.

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

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

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

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

    Alias for this |> process1.dropLast.

    Alias for this |> process1.dropLast.

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

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

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

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

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

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

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

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

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

    Definition Classes
    Process1Ops
  44. 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 Process[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
  45. def ensuring(cond: (Process[F, O]) ⇒ Boolean, msg: ⇒ Any): Process[F, O]
    Implicit
    This member is added by an implicit conversion from Process[F, O] to Ensuring[Process[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  46. def ensuring(cond: (Process[F, O]) ⇒ Boolean): Process[F, O]
    Implicit
    This member is added by an implicit conversion from Process[F, O] to Ensuring[Process[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  47. def ensuring(cond: Boolean, msg: ⇒ Any): Process[F, O]
    Implicit
    This member is added by an implicit conversion from Process[F, O] to Ensuring[Process[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  48. def ensuring(cond: Boolean): Process[F, O]
    Implicit
    This member is added by an implicit conversion from Process[F, O] to Ensuring[Process[F, O]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  49. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  50. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  51. 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.

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

    Alias for this |> process1.exists(f)

    Alias for this |> process1.exists(f)

    Definition Classes
    Process1Ops
  53. final def fby[F2[x] >: F[x], O2 >: O](p2: ⇒ Process[F2, O2]): Process[F2, O2]

    Alias for append

  54. 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 Process[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).
    Definition Classes
    Process1Syntax
  55. def filter(f: (O) ⇒ Boolean): Process[F, O]

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

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

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

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

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

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

    Alias for this |> process1.find(f)

    Alias for this |> process1.find(f)

    Definition Classes
    Process1Ops
  59. 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.

  60. 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
  61. 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
  62. 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
  63. 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
  64. 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
  65. 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
  66. 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
  67. def forall(f: (O) ⇒ Boolean): Process[F, Boolean]

    Alias for this |> process1.forall(f)

    Alias for this |> process1.forall(f)

    Definition Classes
    Process1Ops
  68. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from Process[F, O] to StringFormat[Process[F, O]] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()
  69. 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 Process[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
    SourceSyntax
  70. 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.

  71. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  72. 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.

  73. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  74. 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
  75. def intersperse[O2 >: O](sep: O2): Process[F, O2]

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

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

    Definition Classes
    Process1Ops
  76. final def isHalt: Boolean

    Returns true, if this process is halted

  77. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  78. 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

  79. def last: Process[F, O]

    Alias for this |> process1.last.

    Alias for this |> process1.last.

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

    Alias for this |> process1.last.

    Alias for this |> process1.last.

    Definition Classes
    Process1Ops
  81. 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 Process[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).
    Definition Classes
    Process1Syntax
  82. 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 Process[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).
    Definition Classes
    Process1Syntax
  83. final def map[O2](f: (O) ⇒ O2): Process[F, O2]

    Transforms the output values of this Process using f.

  84. 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
  85. def maximum[O2 >: O](implicit O2: Order[O2]): Process[F, O2]

    Alias for this |> process1.maximum.

    Alias for this |> process1.maximum.

    Definition Classes
    Process1Ops
  86. 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
  87. 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
  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
    This member is added by an implicit conversion from Process[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
  89. def minimum[O2 >: O](implicit O2: Order[O2]): Process[F, O2]

    Alias for this |> process1.minimum.

    Alias for this |> process1.minimum.

    Definition Classes
    Process1Ops
  90. 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
  91. 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
  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 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 Process[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
  96. 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 Process[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
    SourceSyntax
  97. 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 Process[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
  98. 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.

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

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

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

  102. def once: Process[F, O]

    Alias for this |> Process.await1.

    Alias for this |> Process.await1.

    Definition Classes
    Process1Ops
  103. 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.

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

  105. 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 Process[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]).
    Definition Classes
    SinkTaskSyntax
  106. def prefixSums[O2 >: O](implicit N: Numeric[O2]): Process[F, O2]

    Alias for this |> process1.prefixSums

    Alias for this |> process1.prefixSums

    Definition Classes
    Process1Ops
  107. def prepend[O2 >: O](os: Seq[O2]): Process[F, O2]

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

  108. 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
  109. 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
  110. 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
  111. 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
  112. 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
  113. 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
  114. 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.

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

    Run this Process, purely for its effects.

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

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

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

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

  120. 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
  121. 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
  122. 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
  123. 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
  124. 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
  125. 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
  126. 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
  127. def shiftRight[O2 >: O](head: O2*): Process[F, O2]

    Alias for this |> process1.shiftRight(head)

    Alias for this |> process1.shiftRight(head)

    Definition Classes
    Process1Ops
  128. 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
  129. def sliding(n: Int): Process[F, Vector[O]]

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

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

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

    Alias for this |> process1.split(f)

    Alias for this |> process1.split(f)

    Definition Classes
    Process1Ops
  131. 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
  132. def splitWith(f: (O) ⇒ Boolean): Process[F, Vector[O]]

    Alias for this |> process1.splitWith(f)

    Alias for this |> process1.splitWith(f)

    Definition Classes
    Process1Ops
  133. 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
  134. 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.

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

    Alias for this |> process1.sum

    Alias for this |> process1.sum

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

    p.suspendStep propagates exceptions to p.

  137. final def swallowKill: Process[F, O]

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

  138. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  139. def tail: Process[F, O]

    Alias for this |> process1.tail.

    Alias for this |> process1.tail.

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

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    Process1Ops
  144. 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.

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

    Alias for this |> process1.terminated.

    Alias for this |> process1.terminated.

    Definition Classes
    Process1Ops
  146. 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 Process[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
  147. 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 Process[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
  148. 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 Process[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
    SourceSyntax
  149. def toString(): String
    Definition Classes
    AnyRef → Any
  150. def translate[G[_]](f: ~>[F, G]): Process[G, O]

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

  151. final def trim: Process[F, O]

    Remove any leading emitted values from this Process.

    Remove any leading emitted values from this Process.

    Annotations
    @tailrec()
  152. final def uncons[F2[x] >: F[x], O2 >: O](implicit F: Monad[F2], C: Catchable[F2]): F2[(O2, Process[F2, O2])]
  153. final def unconsOption[F2[x] >: F[x], O2 >: O](implicit F: Monad[F2], C: Catchable[F2]): F2[Option[(O2, Process[F2, O2])]]
  154. 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.

  155. 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
  156. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  157. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  158. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  159. 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
  160. 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 Process[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
  161. 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 Process[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
  162. 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 Process[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
  163. 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
  164. 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
  165. 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
  166. def zipWithIndex: Process[F, (O, Int)]

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

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

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

    Alias for this |> process1.zipWithNext.

    Alias for this |> process1.zipWithNext.

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

    Alias for this |> process1.zipWithPrevious.

    Alias for this |> process1.zipWithPrevious.

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

    Alias for this |> process1.zipWithPreviousAndNext.

    Alias for this |> process1.zipWithPreviousAndNext.

    Definition Classes
    Process1Ops
  170. 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
  171. 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
  172. 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
  173. final def |>[O2](p2: Process1[O, O2]): Process[F, O2]

    Operator alias for pipe.

  174. def →[B](y: B): (Process[F, O], B)
    Implicit
    This member is added by an implicit conversion from Process[F, O] to ArrowAssoc[Process[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. val self: Process[Task, O]
    Implicit
    This member is added by an implicit conversion from Process[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:
    (process: SourceSyntax[O]).self
    Definition Classes
    SourceSyntax → WyeOps
  2. val self: Process1[Any, O]
    Implicit
    This member is added by an implicit conversion from Process[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:
    (process: Process1Syntax[Any, O]).self
    Definition Classes
    Process1Syntax
  3. val self: Wye[Any, Any, O]
    Implicit
    This member is added by an implicit conversion from Process[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:
    (process: WyeSyntax[Any, Any, O]).self
    Definition Classes
    WyeSyntax
  4. val self: Writer[Task, W, O]
    Implicit
    This member is added by an implicit conversion from Process[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:
    (process: WriterTaskSyntax[W, O]).self
    Definition Classes
    WriterTaskSyntax
  5. val self: Tee[Any, Any, O]
    Implicit
    This member is added by an implicit conversion from Process[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:
    (process: TeeSyntax[Any, Any, O]).self
    Definition Classes
    TeeSyntax
  6. val self: Sink[Task, Any]
    Implicit
    This member is added by an implicit conversion from Process[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:
    (process: SinkTaskSyntax[Any]).self
    Definition Classes
    SinkTaskSyntax

Inherited from TeeOps[F, O]

Inherited from Process1Ops[F, O]

Inherited from AnyRef

Inherited from Any

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

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

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

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

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

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

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

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

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

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

Ungrouped