Append

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

   Alias for append

   Definition Classes

   Process

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.

   Definition Classes

   Process

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.

   Definition Classes

   Process

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.

   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

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.

    Definition Classes

    Process

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

    Definition Classes

    Process

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.

    Ignore all outputs of this Process.

    Definition Classes

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

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

    

    Alias for this |> process1.exists(f)

    Alias for this |> process1.exists(f)

    Definition Classes

    Process1Ops

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

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

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.

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

    Definition Classes

    Process

41. def fold[O2 >: O](b: O2)(f: (O2, O2) ⇒ O2): Process[F, O2]

    

    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.

    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

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.

    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

52. val head: HaltEmitOrAwait[F, O]

    

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

    Returns true, if this process is halted

    Definition Classes

    Process

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

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

    Definition Classes

    Process

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.

    Transforms the output values of this Process using f.

    Definition Classes

    Process

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

    

    Alias for this |> process1.maximum.

    Alias for this |> process1.maximum.

    Definition Classes

    Process1Ops

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

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

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

    

    Alias for this |> process1.minimum.

    Alias for this |> process1.minimum.

    Definition Classes

    Process1Ops

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

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

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

    

    Definition Classes

    AnyRef

68. final def notify(): Unit

    

    Definition Classes

    AnyRef

69. final def notifyAll(): Unit

    

    Definition Classes

    AnyRef

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

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

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

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

74. def once: Process[F, O]

    

    Alias for this |> Process.await1.

    Alias for this |> Process.await1.

    Definition Classes

    Process1Ops

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

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

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

    

    Alias for this |> process1.prefixSums

    Alias for this |> process1.prefixSums

    Definition Classes

    Process1Ops

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    

    Alias for this |> process1.shiftRight(head)

    Alias for this |> process1.shiftRight(head)

    Definition Classes

    Process1Ops

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

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

     

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

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

     Definition Classes

     Process1Ops

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

     

     Alias for this |> process1.split(f)

     Alias for this |> process1.split(f)

     Definition Classes

     Process1Ops

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

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

     

     Alias for this |> process1.splitWith(f)

     Alias for this |> process1.splitWith(f)

     Definition Classes

     Process1Ops

104. val stack: Vector[(Cause) ⇒ Trampoline[Process[F, O]]]

     

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

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

     

     Alias for this |> process1.sum

     Alias for this |> process1.sum

     Definition Classes

     Process1Ops

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

     

     p.suspendStep propagates exceptions to p.

     p.suspendStep propagates exceptions to p.

     Definition Classes

     Process

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

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

     

     Definition Classes

     AnyRef

110. def tail: Process[F, O]

     

     Alias for this |> process1.tail.

     Alias for this |> process1.tail.

     Definition Classes

     Process1Ops

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

     

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

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

     Definition Classes

     Process1Ops

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

     

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

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

     Definition Classes

     Process1Ops

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

     

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

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

     Definition Classes

     Process1Ops

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

     

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

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

     Definition Classes

     Process1Ops

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

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

     

     Alias for this |> process1.terminated.

     Alias for this |> process1.terminated.

     Definition Classes

     Process1Ops

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

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

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

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

121. final def wait(): Unit

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

     

     Definition Classes

     AnyRef

     Annotations

     @throws( ... )

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

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

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

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

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

     

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

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

     Definition Classes

     Process1Ops

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

     

     Alias for this |> process1.zipWithNext.

     Alias for this |> process1.zipWithNext.

     Definition Classes

     Process1Ops

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

     

     Alias for this |> process1.zipWithPrevious.

     Alias for this |> process1.zipWithPrevious.

     Definition Classes

     Process1Ops

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

     

     Alias for this |> process1.zipWithPreviousAndNext.

     Alias for this |> process1.zipWithPreviousAndNext.

     Definition Classes

     Process1Ops

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

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

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

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

     

     Operator alias for pipe.

     Operator alias for pipe.

     Definition Classes

     Process