Alias for append
Alias for append
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
.
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.
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.
Alias for this |> process1.awaitOption
.
Alias for this |> process1.awaitOption
.
Alias for this |> process1.buffer(n)
.
Alias for this |> process1.buffer(n)
.
Alias for this |> process1.bufferAll
.
Alias for this |> process1.bufferAll
.
Alias for this |> process1.bufferBy(f)
.
Alias for this |> process1.bufferBy(f)
.
Attached cause
when this Process terminates.
Attached cause
when this Process terminates. See Cause.causedBy
for semantics.
Alias for this |> process1.chunk(n)
.
Alias for this |> process1.chunk(n)
.
Alias for this |> process1.chunkAll
.
Alias for this |> process1.chunkAll
.
Alias for this |> process1.chunkBy(f)
.
Alias for this |> process1.chunkBy(f)
.
Alias for this |> process1.chunkBy2(f)
.
Alias for this |> process1.chunkBy2(f)
.
Alias for this |> process1.collect(pf)
.
Alias for this |> process1.collect(pf)
.
Alias for this |> process1.collectFirst(pf)
.
Alias for this |> process1.collectFirst(pf)
.
Alias for this |> process1.delete(f)
.
Alias for this |> process1.delete(f)
.
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
Alias for this |> process1.distinctConsecutive
.
Alias for this |> process1.distinctConsecutive
.
Alias for this |> process1.distinctConsecutiveBy(f)
.
Alias for this |> process1.distinctConsecutiveBy(f)
.
Ignore all outputs of this Process
.
Ignore all outputs of this Process
.
Alias for this |> process1.drop(n)
.
Alias for this |> process1.drop(n)
.
Alias for this |> process1.dropLast
.
Alias for this |> process1.dropLast
.
Alias for this |> process1.dropLastIf(p)
.
Alias for this |> process1.dropLastIf(p)
.
Alias for this |> process1.dropRight(n)
.
Alias for this |> process1.dropRight(n)
.
Alias for this |> process1.dropWhile(f)
.
Alias for this |> process1.dropWhile(f)
.
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
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
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.
Alias for this |> process1.exists(f)
Alias for this |> process1.exists(f)
Alias for append
Alias for append
Alias for this |> process1.filter(f)
.
Alias for this |> process1.filter(f)
.
Alias for this |> process1.filterBy2(f)
.
Alias for this |> process1.filterBy2(f)
.
Alias for this |> process1.find(f)
Alias for this |> process1.find(f)
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
.
Transform the write side of this Writer
.
Transform the write side of this Writer
.
Transform the write side of this Writer
.
Transform the write side of this Writer
.
Alias for this |> process1.fold(b)(f)
.
Alias for this |> process1.fold(b)(f)
.
Alias for this |> process1.fold1(f)
.
Alias for this |> process1.fold1(f)
.
Alias for this |> process1.fold1Map(f)(M)
.
Alias for this |> process1.fold1Map(f)(M)
.
Alias for this |> process1.fold1Monoid(M)
Alias for this |> process1.fold1Monoid(M)
Alias for this |> process1.foldMap(f)(M)
.
Alias for this |> process1.foldMap(f)(M)
.
Alias for this |> process1.foldMonoid(M)
Alias for this |> process1.foldMonoid(M)
Alias for this |> process1.foldSemigroup(M)
.
Alias for this |> process1.foldSemigroup(M)
.
Alias for this |> process1.forall(f)
Alias for this |> process1.forall(f)
Read chunks of bufSize
from input, then use Nondeterminism.gatherUnordered
to run all these actions to completion.
Read chunks of bufSize
from input, then use Nondeterminism.gatherUnordered
to run all these actions to completion.
Read chunks of bufSize
from input, then use Nondeterminism.gatherUnordered
to run all these actions to completion.
Read chunks of bufSize
from input, then use Nondeterminism.gatherUnordered
to run all these actions to completion.
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.
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.
Alternate emitting elements from this
and p2
, starting with this
.
Alternate emitting elements from this
and p2
, starting with this
.
Alias for this |> process1.intersperse(sep)
.
Alias for this |> process1.intersperse(sep)
.
Returns true, if this process is halted
Returns true, if this process is halted
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
Alias for this |> process1.last
.
Alias for this |> process1.last
.
Alias for this |> process1.last
.
Alias for this |> process1.last
.
Transforms the output values of this Process
using f
.
Transforms the output values of this Process
using f
.
Alias for this |> process1.mapAccumulate(s)(f)
.
Alias for this |> process1.mapAccumulate(s)(f)
.
Map over the output side of this Writer
.
Map over the output side of this Writer
.
Map over the output side of this Writer
.
Map over the output side of this Writer
.
Transform the output of this Channel
Transform the output of this Channel
Transform the output of this Channel
Transform the output of this Channel
Map over the write side of this Writer
.
Map over the write side of this Writer
.
Map over the write side of this Writer
.
Map over the write side of this Writer
.
Alias for this |> process1.maximum
.
Alias for this |> process1.maximum
.
Alias for this |> process1.maximumBy(f)
.
Alias for this |> process1.maximumBy(f)
.
Alias for this |> process1.maximumOf(f)
.
Alias for this |> process1.maximumOf(f)
.
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
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
Alias for this |> process1.minimum
.
Alias for this |> process1.minimum
.
Alias for this |> process1.minimumBy(f)
.
Alias for this |> process1.minimumBy(f)
.
Alias for this |> process1.minimumOf(f)
.
Alias for this |> process1.minimumOf(f)
.
Attach a Sink
to the output of this Process
but echo the original.
Attach a Sink
to the output of this Process
but echo the original.
Attach a Sink
to the output of this Process
but echo the original.
Attach a Sink
to the output of this Process
but echo the original.
Observe the output side of this Writer
using the
given Sink
, keeping it available for subsequent
processing.
Observe the output side of this Writer
using the
given Sink
, keeping it available for subsequent
processing. Also see drainO
.
Observe the output side of this Writer
using the
given Sink
, keeping it available for subsequent
processing.
Observe the output side of this Writer
using the
given Sink
, keeping it available for subsequent
processing. Also see drainO
.
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.
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.
Returns result of channel evaluation tupled with original value passed to channel.
Returns result of channel evaluation tupled with original value passed to channel.
Returns result of channel evaluation tupled with original value passed to channel.
Returns result of channel evaluation tupled with original value passed to channel.
Observe the write side of this Writer
using the
given Sink
, keeping it available for subsequent
processing.
Observe the write side of this Writer
using the
given Sink
, keeping it available for subsequent
processing. Also see drainW
.
Observe the write side of this Writer
using the
given Sink
, keeping it available for subsequent
processing.
Observe the write side of this Writer
using the
given Sink
, keeping it available for subsequent
processing. Also see drainW
.
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.
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.
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.
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.
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.
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.
Alias for this |> Process.await1
.
Alias for this |> Process.await1
.
Like attempt
, but accepts a partial function.
Like attempt
, but accepts a partial function. Unhandled errors are rethrown.
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.
Pipe output side of this Writer
Pipe output side of this Writer
Pipe output side of this Writer
Pipe output side of this Writer
Pipe write side of this Writer
Pipe write side of this Writer
Pipe write side of this Writer
Pipe write side of this Writer
Alias for this |> process1.prefixSums
Alias for this |> process1.prefixSums
Prepend a sequence of elements to the output of this Process
.
Prepend a sequence of elements to the output of this Process
.
Alias for this |> process1.reduce(f)
.
Alias for this |> process1.reduce(f)
.
Alias for this |> process1.reduceMap(f)(M)
.
Alias for this |> process1.reduceMap(f)(M)
.
Alias for this |> process1.reduceMonoid(M)
.
Alias for this |> process1.reduceMonoid(M)
.
Alias for this |> process1.reduceSemigroup(M)
.
Alias for this |> process1.reduceSemigroup(M)
.
Alias for this |> process1.repartition(p)(S)
Alias for this |> process1.repartition(p)(S)
Alias for this |> process1.repartition2(p)(S)
Alias for this |> process1.repartition2(p)(S)
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.
Run this Process
, purely for its effects.
Run this Process
, purely for its effects.
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.
Run this Process
solely for its final emitted value, if one exists.
Run this Process
solely for its final emitted value, if one exists.
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.
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.
Alias for this |> process1.scan(b)(f)
.
Alias for this |> process1.scan(b)(f)
.
Alias for this |> process1.scan1(f)
.
Alias for this |> process1.scan1(f)
.
Alias for this |> process1.scan1Map(f)(M)
.
Alias for this |> process1.scan1Map(f)(M)
.
Alias for this |> process1.scan1Monoid(M)
.
Alias for this |> process1.scan1Monoid(M)
.
Alias for this |> process1.scanMap(f)(M)
.
Alias for this |> process1.scanMap(f)(M)
.
Alias for this |> process1.scanMonoid(M)
.
Alias for this |> process1.scanMonoid(M)
.
Alias for this |> process1.scanSemigroup(M)
.
Alias for this |> process1.scanSemigroup(M)
.
Read chunks of bufSize
from input, then use Nondeterminism.gather
to run all these actions to completion and return elements in order.
Read chunks of bufSize
from input, then use Nondeterminism.gather
to run all these actions to completion and return elements in order.
Read chunks of bufSize
from input, then use Nondeterminism.gather
to run all these actions to completion and return elements in order.
Read chunks of bufSize
from input, then use Nondeterminism.gather
to run all these actions to completion and return elements in order.
Alias for this |> process1.shiftRight(head)
Alias for this |> process1.shiftRight(head)
Delay running this Process
until awaken
becomes true for the first time.
Delay running this Process
until awaken
becomes true for the first time.
Alias for this |> process1.sliding(n)
.
Alias for this |> process1.sliding(n)
.
Alias for this |> process1.split(f)
Alias for this |> process1.split(f)
Alias for this |> process1.splitOn(p)
Alias for this |> process1.splitOn(p)
Alias for this |> process1.splitWith(f)
Alias for this |> process1.splitWith(f)
Alias for this |> process1.stateScan(init)(f)
.
Alias for this |> process1.stateScan(init)(f)
.
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.
Alias for this |> process1.sum
Alias for this |> process1.sum
p.suspendStep
propagates exceptions to p
.
p.suspendStep
propagates exceptions to p
.
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
Alias for this |> process1.tail
.
Alias for this |> process1.tail
.
Alias for this |> process1.take(n)
.
Alias for this |> process1.take(n)
.
Alias for this |> process1.takeRight(n)
.
Alias for this |> process1.takeRight(n)
.
Alias for this |> process1.takeThrough(f)
.
Alias for this |> process1.takeThrough(f)
.
Alias for this |> process1.takeWhile(f)
.
Alias for this |> process1.takeWhile(f)
.
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
.
Alias for this |> process1.terminated
.
Alias for this |> process1.terminated
.
Feed this Process
through the given effectful Channel
.
Feed this Process
through the given effectful Channel
.
Feed this Process
through the given effectful Channel
.
Feed this Process
through the given effectful Channel
.
Feed this Writer
's output through the provided effectful Channel
.
Feed this Writer
's output through the provided effectful Channel
.
Feed this Writer
's output through the provided effectful Channel
.
Feed this Writer
's output through the provided effectful Channel
.
Feed this Process
through the given effectful Channel
, signaling
termination to f
via None
.
Feed this Process
through the given effectful Channel
, signaling
termination to f
via None
. Useful to allow f
to flush any
buffered values to the output when it detects termination, see
scalaz.stream.io.bufferedChannel combinator.
Feed this Process
through the given effectful Channel
, signaling
termination to f
via None
.
Feed this Process
through the given effectful Channel
, signaling
termination to f
via None
. Useful to allow f
to flush any
buffered values to the output when it detects termination, see
scalaz.stream.io.bufferedChannel combinator.
Feed this Writer
's writes through the provided effectful Channel
.
Feed this Writer
's writes through the provided effectful Channel
.
Feed this Writer
's writes through the provided effectful Channel
.
Feed this Writer
's writes through the provided effectful Channel
.
Attaches Sink
to this Process
Attaches Sink
to this Process
Attaches Sink
to this Process
Attaches Sink
to this Process
Converts Sink
to Channel
, that will perform the side effect and echo its input.
Converts Sink
to Channel
, that will perform the side effect and echo its input.
Converts Sink
to Channel
, that will perform the side effect and echo its input.
Converts Sink
to Channel
, that will perform the side effect and echo its input.
Converts this Process0
to a Map
.
Converts this Process0
to a Map
.
Converts this Process0
to a Map
.
Converts this Process0
to a Map
.
Converts this Process0
to a SortedMap
.
Converts this Process0
to a SortedMap
.
Converts this Process0
to a SortedMap
.
Converts this Process0
to a SortedMap
.
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.
Remove any leading emitted values from this Process
.
Remove any leading emitted values from this Process
.
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
.
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.
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.
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
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
Non-deterministic version of zipWith
.
Non-deterministic version of zipWith
. Note this terminates whenever one of streams terminate
Non-deterministic version of zipWith
.
Non-deterministic version of zipWith
. Note this terminates whenever one of streams terminate
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
.
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
.
Alias for this |> process1.zipWithIndex[A,N]*
.
Alias for this |> process1.zipWithIndex[A,N]*
.
Alias for this |> process1.zipWithIndex[A]*
.
Alias for this |> process1.zipWithIndex[A]*
.
Alias for this |> process1.zipWithNext
.
Alias for this |> process1.zipWithNext
.
Alias for this |> process1.zipWithPrevious
.
Alias for this |> process1.zipWithPrevious
.
Alias for this |> process1.zipWithPreviousAndNext
.
Alias for this |> process1.zipWithPreviousAndNext
.
Alias for this |> process1.zipWithScan(z)(next)
.
Alias for this |> process1.zipWithScan(z)(next)
.
Alias for this |> process1.zipWithScan(z)(next)
.
Alias for this |> process1.zipWithScan(z)(next)
.
Alias for this |> process1.zipWithState(z)(next)
.
Alias for this |> process1.zipWithState(z)(next)
.
Operator alias for pipe
.
Operator alias for pipe
.
Apply this Process
to an Iterable
.
Apply this Process
to an Iterable
.
(halt: Process1Syntax[Any, O]).apply(input)
Apply a Wye
to two Iterable
inputs.
Apply a Wye
to two Iterable
inputs.
(halt: WyeSyntax[Any, Any, O]).apply(input, input2)
Apply a Wye
to two Iterable
inputs.
Apply a Wye
to two Iterable
inputs.
(halt: WyeSyntax[Any, Any, O]).apply(input, input2)
Apply this Process
to an Iterable
.
Apply this Process
to an Iterable
.
(halt: Process1Syntax[Any, O]).apply(input)
Transform the left input of the given Wye
using a Process1
.
Transform the left input of the given Wye
using a Process1
.
(halt: WyeSyntax[Any, Any, O]).attachL(f)
Transform the left input of the given Wye
using a Process1
.
Transform the left input of the given Wye
using a Process1
.
(halt: WyeSyntax[Any, Any, O]).attachL(f)
Transform the right input of the given Wye
using a Process1
.
Transform the right input of the given Wye
using a Process1
.
(halt: WyeSyntax[Any, Any, O]).attachR(f)
Transform the right input of the given Wye
using a Process1
.
Transform the right input of the given Wye
using a Process1
.
(halt: WyeSyntax[Any, Any, O]).attachR(f)
Transform the input of this Process1
.
Transform the input of this Process1
.
(halt: Process1Syntax[Any, O]).contramap(f)
Transform the input of this Channel
.
Transform the input of this Channel
.
(halt: ChannelSyntax[F, Any, O]).contramap(f)
Transform the input of this Process1
.
Transform the input of this Process1
.
(halt: Process1Syntax[Any, O]).contramap(f)
Transform the input of this Channel
.
Transform the input of this Channel
.
(halt: ChannelSyntax[F, Any, O]).contramap(f)
Transform the left input to a Wye
.
Transform the left input to a Wye
.
(halt: WyeSyntax[Any, Any, O]).contramapL(f)
Transform the left input to a Tee
.
Transform the left input to a Tee
.
(halt: TeeSyntax[Any, Any, O]).contramapL(f)
Transform the left input to a Wye
.
Transform the left input to a Wye
.
(halt: WyeSyntax[Any, Any, O]).contramapL(f)
Transform the left input to a Tee
.
Transform the left input to a Tee
.
(halt: TeeSyntax[Any, Any, O]).contramapL(f)
Transform the right input to a Wye
.
Transform the right input to a Wye
.
(halt: WyeSyntax[Any, Any, O]).contramapR(f)
Transform the right input to a Tee
.
Transform the right input to a Tee
.
(halt: TeeSyntax[Any, Any, O]).contramapR(f)
Transform the right input to a Wye
.
Transform the right input to a Wye
.
(halt: WyeSyntax[Any, Any, O]).contramapR(f)
Transform the right input to a Tee
.
Transform the right input to a Tee
.
(halt: TeeSyntax[Any, Any, O]).contramapR(f)
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.
(halt: WyeSyntax[Any, Any, O]).detach1L
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.
(halt: WyeSyntax[Any, Any, O]).detach1L
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.
(halt: WyeSyntax[Any, Any, O]).detach1R
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.
(halt: WyeSyntax[Any, Any, O]).detach1R
Ignore the output side of this Writer
.
Ignore the output side of this Writer
.
(halt: WriterSyntax[F, W, O]).drainO
Ignore the output side of this Writer
.
Ignore the output side of this Writer
.
(halt: WriterSyntax[F, W, O]).drainO
Ignore the write side of this Writer
.
Ignore the write side of this Writer
.
(halt: WriterSyntax[F, W, O]).drainW
Ignore the write side of this Writer
.
Ignore the write side of this Writer
.
(halt: WriterSyntax[F, W, O]).drainW
Evaluate the stream of F
actions produced by this Process
.
Evaluate the stream of F
actions produced by this Process
.
This sequences F
actions strictly--the first F
action will
be evaluated before work begins on producing the next F
action. To allow for concurrent evaluation, use sequence
or gather
.
(halt: EvalProcess[F, O]).eval
Evaluate the stream of F
actions produced by this Process
.
Evaluate the stream of F
actions produced by this Process
.
This sequences F
actions strictly--the first F
action will
be evaluated before work begins on producing the next F
action. To allow for concurrent evaluation, use sequence
or gather
.
(halt: EvalProcess[F, O]).eval
Feed a single input to this Process1
.
Feed a single input to this Process1
.
(halt: Process1Syntax[Any, O]).feed1(i)
Feed a single input to this Process1
.
Feed a single input to this Process1
.
(halt: Process1Syntax[Any, O]).feed1(i)
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.
(halt: SourceSyntax[O]).forwardFill(S)
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.
(halt: SourceSyntax[O]).forwardFill(S)
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.
(halt: Process1Syntax[Any, O]).liftL
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.
(halt: Process1Syntax[Any, O]).liftL
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.
(halt: Process1Syntax[Any, O]).liftR
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.
(halt: Process1Syntax[Any, O]).liftR
converts sink to sink that first pipes received I0
to supplied p1
converts sink to sink that first pipes received I0
to supplied p1
(halt: SinkTaskSyntax[Any]).pipeIn(p1)
converts sink to sink that first pipes received I0
to supplied p1
converts sink to sink that first pipes received I0
to supplied p1
(halt: SinkTaskSyntax[Any]).pipeIn(p1)
(halt: SourceSyntax[O]).self
(halt: Process1Syntax[Any, O]).self
(halt: Process0Syntax[O]).self
(halt: ProcessSyntax[F, O]).self
(halt: ChannelSyntax[F, Any, O]).self
(halt: EvalProcess[F, O]).self
(halt: WyeSyntax[Any, Any, O]).self
(halt: WriterTaskSyntax[W, O]).self
(halt: WriterSyntax[F, W, O]).self
(halt: TeeSyntax[Any, Any, O]).self
(halt: SinkTaskSyntax[Any]).self
(halt: SinkSyntax[F, Any]).self
(halt: SourceSyntax[O]).self
(halt: Process0Syntax[O]).self
(halt: EvalProcess[F, O]).self
(halt: ProcessSyntax[F, O]).self
(halt: WyeSyntax[Any, Any, O]).self
(halt: WriterTaskSyntax[W, O]).self
(halt: WriterSyntax[F, W, O]).self
(halt: TeeSyntax[Any, Any, O]).self
(halt: SinkTaskSyntax[Any]).self
(halt: SinkSyntax[F, Any]).self
(halt: Process1Syntax[Any, O]).self
(halt: ChannelSyntax[F, Any, O]).self
(halt: StringAdd).self
(halt: StringFormat).self
Remove the output side of this Writer
.
Remove the output side of this Writer
.
(halt: WriterSyntax[F, W, O]).stripO
Remove the output side of this Writer
.
Remove the output side of this Writer
.
(halt: WriterSyntax[F, W, O]).stripO
Remove the write side of this Writer
.
Remove the write side of this Writer
.
(halt: WriterSyntax[F, W, O]).stripW
Remove the write side of this Writer
.
Remove the write side of this Writer
.
(halt: WriterSyntax[F, W, O]).stripW
Converts this Process0
to an IndexedSeq
.
Converts this Process0
to an IndexedSeq
.
(halt: Process0Syntax[O]).toIndexedSeq
Converts this Process0
to an IndexedSeq
.
Converts this Process0
to an IndexedSeq
.
(halt: Process0Syntax[O]).toIndexedSeq
Converts this Process0
to a List
.
Converts this Process0
to a List
.
(halt: Process0Syntax[O]).toList
Converts this Process0
to a List
.
Converts this Process0
to a List
.
(halt: Process0Syntax[O]).toList
Converts this Process0
to a Seq
.
Converts this Process0
to a Seq
.
(halt: Process0Syntax[O]).toSeq
Converts this Process0
to a Seq
.
Converts this Process0
to a Seq
.
(halt: Process0Syntax[O]).toSeq
converts process to signal *
converts process to signal *
(halt: SourceSyntax[O]).toSignal(S)
converts process to signal *
converts process to signal *
(halt: SourceSyntax[O]).toSignal(S)
(halt: Process0Syntax[O]).toSource
(halt: Process0Syntax[O]).toSource
Converts this Process0
to a Stream
.
Converts this Process0
to a Stream
.
(halt: Process0Syntax[O]).toStream
Converts this Process0
to a Stream
.
Converts this Process0
to a Stream
.
(halt: Process0Syntax[O]).toStream
Converts this Process0
to a Vector
.
Converts this Process0
to a Vector
.
(halt: Process0Syntax[O]).toVector
Converts this Process0
to a Vector
.
Converts this Process0
to a Vector
.
(halt: Process0Syntax[O]).toVector
Non-deterministic version of zip
.
Non-deterministic version of zip
. Note this terminates whenever one of streams terminate
(halt: SourceSyntax[O]).yip(p2)(S)
Non-deterministic version of zip
.
Non-deterministic version of zip
. Note this terminates whenever one of streams terminate
(halt: SourceSyntax[O]).yip(p2)(S)
(halt: Process0Syntax[O]).liftIO
(Since version 0.7) liftIO is deprecated in favor of toSource. It will be removed in a future release.
(halt: Process0Syntax[O]).liftIO
(Since version 0.7) liftIO is deprecated in favor of toSource. It will be removed in a future release.
(halt: ArrowAssoc[Halt]).x
(Since version 2.10.0) Use leftOfArrow
instead
(halt: Ensuring[Halt]).x
(Since version 2.10.0) Use resultOfEnsuring
instead
The
Halt
constructor instructs the driver that the last evaluation of Process completed with supplied cause.