Splitter

Convenience for creating Splitters with a specific In type; useful when type inference can figure out the other type parameters.

Create a Splitter that treats consecutive matched values as substreams. For example, given a matcher like { case c if c.isLetter => c }, a stream like

1 2 3 A B C 4 5 6 D 7 8 E F G H 9

could be treated as having three substreams, where each substream's "context value" is the first letter in that group (because context is always defined by the beginning of the substream).

• A B C with context 'A' (between the 3 and 4)
• D with context 'D' (between the 6 and 7)
• E F G H with context 'E' (between the 8 and 9)

Create a Splitter that treats consecutive values matching the predicate p as substreams with no particular context value. For example, given a matcher like i => i % 2 == 0, a stream like

1 3 2 2 4 5 6 7 8 10 4 3 1

could be treated as having three substreams:

• 2 2 4
• 6
• 8 10 4

Create a splitter that keeps track of a "stack" which is pushed and popped by In events, starting a new substream when the given matcher matches the stack.

The primary use-case for this is when dealing with nestable data formats like XML or JSON, where a token could signify a push to the stack (e.g. an ElemStart event), and where you want to operate on events that occur within some specific stack of elements.

For inputs that cause a push or pop to the stack, whether that input is included as "inside" the pushed context is up to the specific StackLike implementation.

Create a splitter that starts a new substream every time the matcher matches. Any events passed through before the initial match will be discarded, but every event thereafter will be part of a substream. The context for a substream is based on the value returned by the matcher for the event that caused that match.

For example, in a stream like 4 3 2 1 2 3 1 2 1 2 3 4, if our matcher was { case 1 => "yay" }, then we'd have a new substream with context "yay" every time a 1 came through:

• (new context: "yay") 1 2 3
• (new context: "yay") 1 2
• (new context: "yay") 1 2 3 4

Create a splitter that starts a new substream every time the predicate function p returns true for an input. Any inputs passed through before the initial match will be discarded, but every event thereafter will be part of a substream. Context is ignored for substreams from this method - the context type is Any.

For example, in a stream like 4 3 2 1 2 3 1 2 1 2 3 4, if our predicate was { _ == 1 }, then we'd have a new substream starting from each 1 input.

• (new context) 1 2 3
• (new context) 1 2
• (new context) 1 2 3 4