In response to the end of the stream of incoming values, this handler may output any number of final output values via the provided HandlerWrite. The expectation is that a Handler's finish method will only ever be called once before that Handler is discarded, with the exception of Stateless Transformers, which act as their own Handlers and will be reused.

In response to some input value in, this handler may output any number of output values via the provided HandlerWrite, possibly change its internal state, and signal to the upstream caller whether it wants to continue or stop receiving new inputs. Upstream handlers SHOULD avoid making more calls to this handler's push after it returns Signal.Stop.

Wraps this handler as a "top level" handler, which will inject a SpacTraceElement (representing the current input or the "EOF" signal) to any exception is thrown by this handler when calling its step or finish methods.

Used internally by Transformers transform and toPipe methods.

In response to an error thrown and caught from a downstream consumer, this handler may modify the exception on its way back upstream. Used by the "spac frame" transformer.

Returns this transformer, but with a different view of the Out type. The Out <:< Out2 implicit evidence is used to make sure the asInstanceOf cast is safe. This is mostly useful when you know you have a transformer that yields a tuple or some kind of type constructor.

Creates a new transformer which filters and maps the outputs from this transformer

Convenience for this into Parser.drain

Creates a new transformer which filters the outputs from this transformer.

Attach this transformer to a parser, creating a new parser that encapsulates the pair. Values emitted from this transformer will be passed as inputs to the parser, and the resulting output from the parser will be yielded as output by the combined parser.

Creates a new transformer which applies the transformation function f to each of this transformer's outputs.

Creates a new transformer which transforms the outputs of this transformer via the given function f, emitting each individual value from the output of that function in order before continuing.

Like mergeEither, but when both sides have a common output type. This is a less-roundabout way of doing .mergeEither(right).map(_.merge). The same order-of-operations rules apply as with mergeEither, where this transformer "goes first" for each input.

Creates a new transformer which sends inputs to both this transformer and the right transformer. Whenever either this or right emit a value, that value will be emitted from the returned transformer, wrapped as a Left or Right depending on which underlying transformer emitted it. For each individual input, the resulting values emitted by this transformer will be emitted before the resulting values emitted by the right transformer.

Transformer's main abstract method; constructs a new Handler representing this transformer's logic. Transformers are expected to be immutable, but Handlers may be internally-mutable.

Convenience for this into Parser.fold(init)(f)

Convenience for this into Parser.firstOpt

Convenience for this into Parser.tap(f)

Convenience for this into Parser.toList

Convenience for calling push multiple times, aborting early if the signal becomes Stop in response to any one push.

Creates a new transformer which folds outputs from this transformer into a "state" which is emitted each time.

Attach this transformer to the next transformer, creating a single transformer that encapsulates the pair. Values emitted from this transformer will be passed as inputs to the next transformer, and the resulting outputs from the next transformer are emitted as outputs from the combined transformer.

Convert this transformer to a Pipe which will apply this transformer's logic to an fs2 Stream.

Applies this transformer's logic to an iterator, returning a new Iterator which yields values emitted by this transformer when run on the underlying itr.

Returns this transformer, but with less restricted In / Out types.

Alias for filter, used under the hood by for-comprehensions

Creates a copy of this transformer, but with a different toString

Convenience for this into Parser.first

Convenience for this into Parser.first

Convenience for this into Parser.toMap[K, V]

Convenience for this into Parser.toMap[K, V]