Process

Value Members

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

   

   Definition Classes

   AnyRef → Any

2. final def ##(): Int

   

   Definition Classes

   AnyRef → Any

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

   

   Alias for append

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

   

   Definition Classes

   AnyRef → Any

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

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

7. final def asInstanceOf[T0]: T0

   

   Definition Classes

   Any

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

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

   

   Alias for this |> process1.awaitOption.

   Alias for this |> process1.awaitOption.

   Definition Classes

   Process1Ops

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

    

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

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

    Definition Classes

    Process1Ops

11. def bufferAll: Process[F, O]

    

    Alias for this |> process1.bufferAll.

    Alias for this |> process1.bufferAll.

    Definition Classes

    Process1Ops

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

    

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

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

    Definition Classes

    Process1Ops

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

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

    

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

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

    Definition Classes

    Process1Ops

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

    

    Alias for this |> process1.chunkAll.

    Alias for this |> process1.chunkAll.

    Definition Classes

    Process1Ops

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

    

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

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

    Definition Classes

    Process1Ops

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

18. def clone(): AnyRef

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

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

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

    

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

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

    Definition Classes

    Process1Ops

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

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

    

    Alias for this |> process1.distinctConsecutive.

    Alias for this |> process1.distinctConsecutive.

    Definition Classes

    Process1Ops

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

25. final def drain: Process[F, Nothing]

    

    Ignore all outputs of this Process.

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

    

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

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

    Definition Classes

    Process1Ops

27. def dropLast: Process[F, O]

    

    Alias for this |> process1.dropLast.

    Alias for this |> process1.dropLast.

    Definition Classes

    Process1Ops

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

    

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

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

    Definition Classes

    Process1Ops

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

    

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

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

    Definition Classes

    Process1Ops

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

    

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

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

    Definition Classes

    Process1Ops

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

    

    Definition Classes

    AnyRef

32. def equals(arg0: Any): Boolean

    

    Definition Classes

    AnyRef → Any

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

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

    

    Alias for this |> process1.exists(f)

    Alias for this |> process1.exists(f)

    Definition Classes

    Process1Ops

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

    

    Alias for append

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

    

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

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

    Definition Classes

    Process1Ops

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

    

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

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

    Definition Classes

    Process1Ops

38. def finalize(): Unit

    

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

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

    

    Alias for this |> process1.find(f)

    Alias for this |> process1.find(f)

    Definition Classes

    Process1Ops

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

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

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

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

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

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

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

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

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

    

    Alias for this |> process1.forall(f)

    Alias for this |> process1.forall(f)

    Definition Classes

    Process1Ops

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

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

    

    Definition Classes

    AnyRef → Any

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

52. def hashCode(): Int

    

    Definition Classes

    AnyRef → Any

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

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

    

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

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

    Definition Classes

    Process1Ops

55. final def isHalt: Boolean

    

    Returns true, if this process is halted

56. final def isInstanceOf[T0]: Boolean

    

    Definition Classes

    Any

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

58. def last: Process[F, O]

    

    Alias for this |> process1.last.

    Alias for this |> process1.last.

    Definition Classes

    Process1Ops

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

    

    Alias for this |> process1.last.

    Alias for this |> process1.last.

    Definition Classes

    Process1Ops

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

    

    Transforms the output values of this Process using f.

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

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

    

    Alias for this |> process1.maximum.

    Alias for this |> process1.maximum.

    Definition Classes

    Process1Ops

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

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

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

    

    Alias for this |> process1.minimum.

    Alias for this |> process1.minimum.

    Definition Classes

    Process1Ops

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

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

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

    

    Definition Classes

    AnyRef

69. final def notify(): Unit

    

    Definition Classes

    AnyRef

70. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

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

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

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

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

75. def once: Process[F, O]

    

    Alias for this |> Process.await1.

    Alias for this |> Process.await1.

    Definition Classes

    Process1Ops

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

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

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

    

    Alias for this |> process1.prefixSums

    Alias for this |> process1.prefixSums

    Definition Classes

    Process1Ops

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

    

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

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

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

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

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

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

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

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

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

    

    Run this Process, purely for its effects.

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

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

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

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

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

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

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

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

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

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

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

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

    

    Alias for this |> process1.shiftRight(head)

    Alias for this |> process1.shiftRight(head)

    Definition Classes

    Process1Ops

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

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

     

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

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

     Definition Classes

     Process1Ops

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

     

     Alias for this |> process1.split(f)

     Alias for this |> process1.split(f)

     Definition Classes

     Process1Ops

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

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

     

     Alias for this |> process1.splitWith(f)

     Alias for this |> process1.splitWith(f)

     Definition Classes

     Process1Ops

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

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

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

     

     Alias for this |> process1.sum

     Alias for this |> process1.sum

     Definition Classes

     Process1Ops

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

     

     p.suspendStep propagates exceptions to p.

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

     

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

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

     

     Definition Classes

     AnyRef

111. def tail: Process[F, O]

     

     Alias for this |> process1.tail.

     Alias for this |> process1.tail.

     Definition Classes

     Process1Ops

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

     

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

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

     Definition Classes

     Process1Ops

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

     

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

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

     Definition Classes

     Process1Ops

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

     

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

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

     Definition Classes

     Process1Ops

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

     

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

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

     Definition Classes

     Process1Ops

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

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

     

     Alias for this |> process1.terminated.

     Alias for this |> process1.terminated.

     Definition Classes

     Process1Ops

118. def toString(): String

     

     Definition Classes

     AnyRef → Any

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

     

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

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

     

     Remove any leading emitted values from this Process.

     Remove any leading emitted values from this Process.

     Annotations

     @tailrec()

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

     

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

     

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

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

125. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

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

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

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

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

     

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

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

     Definition Classes

     Process1Ops

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

     

     Alias for this |> process1.zipWithNext.

     Alias for this |> process1.zipWithNext.

     Definition Classes

     Process1Ops

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

     

     Alias for this |> process1.zipWithPrevious.

     Alias for this |> process1.zipWithPrevious.

     Definition Classes

     Process1Ops

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

     

     Alias for this |> process1.zipWithPreviousAndNext.

     Alias for this |> process1.zipWithPreviousAndNext.

     Definition Classes

     Process1Ops

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

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

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

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

     

     Operator alias for pipe.