pipe
Related Doc:
package fs2
Allows stepping of a pure pipe.
Allows stepping of a pure pipe. Each invocation of step results in a value of the Stepper.Step algebra, indicating that the pipe is either done, it failed with an exception, it emitted a chunk of output, or it is awaiting input.
Behaves like the identity function, but requests n elements at a time from the input.
Behaves like the identity stream, but emits no output until the source is exhausted.
Behaves like the identity stream, but requests elements from its input in blocks that end whenever the predicate switches from true to false.
Emits only elements that are distinct from their immediate predecessors, using natural equality for comparison.
Emits only elements that are distinct from their immediate predecessors
according to f, using natural equality for comparison.
Emits only elements that are distinct from their immediate predecessors
according to f, using natural equality for comparison.
Note that f is called for each element in the stream multiple times
and hence should be fast (e.g., an accessor). It is not intended to be
used for computationally intensive conversions. For such conversions,
consider something like: src.map(i => (i, f(i))).changesBy(_._2).map(_._1)
Outputs chunks with a limited maximum size, splitting as necessary.
Outputs a list of chunks, the total size of all chunks is limited and split as necessary.
Outputs all chunks from the input Handle.
Map/filter simultaneously.
Map/filter simultaneously. Calls collect on each Chunk in the stream.
Emits the first element of the Stream for which the partial function is defined.
Converts a pure pipe to an effectful pipe of the specified type.
Skips the first element that matches the predicate.
Pass elements of s through both f and g, then combine the two resulting streams.
Pass elements of s through both f and g, then combine the two resulting streams.
Implemented by enqueueing elements as they are seen by f onto a Queue used by the g branch.
USE EXTREME CARE WHEN USING THIS FUNCTION. Deadlocks are possible if combine pulls from the g
branch synchronously before the queue has been populated by the f branch.
The combine function receives an F[Int] effect which evaluates to the current size of the
g-branch's queue.
When possible, use one of the safe combinators like observe, which are built using this function,
in preference to using this function directly.
Drops n elements of the input, then echoes the rest.
Drops the last element.
Drops the last element if the predicate evaluates to true.
Emits all but the last n elements of the input.
Drops the elements of the input until the predicate p fails, then echoes the rest.
Like pipe.scan, but accepts a function returning an F[_]
Emits true as soon as a matching element is received, else false if no input matches
Emits only inputs which match the supplied predicate.
Like filter, but the predicate f depends on the previously emitted and
current elements.
Emits the first input (if any) which matches the supplied predicate, to the output of the returned Pull
Folds all inputs using an initial value z and supplied binary operator,
and emits a single element stream.
Folds all inputs using the supplied binary operator, and emits a single-element stream, or the empty stream if the input is empty.
Emits a single true value if all input matches the predicate.
Emits a single true value if all input matches the predicate.
Halts with false as soon as a non-matching element is received.
Partitions the input into a stream of chunks according to a discriminator function.
Partitions the input into a stream of chunks according to a discriminator function. Each chunk is annotated with the value of the discriminator function applied to any of the chunk's elements.
Emits the first element of this stream (if non-empty) and then halts.
Identity pipe - every input is output unchanged.
Emits the specified separator between every pair of elements in the source stream.
Joins a stream of pipes in to a single pipe.
Joins a stream of pipes in to a single pipe. Input is fed to the first pipe until it terminates, at which point input is fed to the second pipe, and so on.
Asynchronous version of join that queues up to maxQueued elements.
Queue based version of join that uses the specified queue.
Returns the last element of the input Handle, if non-empty.
Returns the last element of the input Handle if non-empty, otherwise li.
Applies the specified pure function to each input and emits the result.
Applies the specified pure function to each input and emits the result.
Works in a chunky fashion and creates a Chunk.indexedSeq for each mapped chunk.
Maps a running total according to S and the input with the function f.
Maps a running total according to S and the input with the function f.
scala> Stream("Hello", "World") | .mapAccumulate(0)((l, s) => (l + s.length, s.head)).toVector res0: Vector[(Int, Char)] = Vector((5,H), (10,W))
Outputs a transformed version of all chunks from the input Handle.
Synchronously send values through sink.
Send chunks through sink, allowing up to maxQueued pending _chunks_ before blocking s.
Behaves like id, but starts fetching the next chunk before emitting the current,
enabling processing on either side of the prefetch to run in parallel.
Modifies the chunk structure of the underlying stream, emitting potentially unboxed
chunks of n elements.
Modifies the chunk structure of the underlying stream, emitting potentially unboxed
chunks of n elements. If allowFewer is true, the final chunk of the stream
may be less than n elements. Otherwise, if the final chunk is less than n
elements, it is dropped.
Alias for pipe.fold1
Rethrows any Left(err).
Rethrows any Left(err). Preserves chunkiness.
Left fold which outputs all intermediate results.
Left fold which outputs all intermediate results. Example:
Stream(1,2,3,4) through pipe.scan(0)(_ + _) == Stream(0,1,3,6,10).
More generally:
Stream().scan(z)(f) == Stream(z)
Stream(x1).scan(z)(f) == Stream(z, f(z,x1))
Stream(x1,x2).scan(z)(f) == Stream(z, f(z,x1), f(f(z,x1),x2))
etc
Works in a chunky fashion, and creates a Chunk.indexedSeq for each converted chunk.
Like pipe.scan, but uses the first element of the stream as the seed.
Emits the given values, then echoes the rest of the input.
Groups inputs in fixed size chunks by passing a "sliding window"
of size n over them.
Groups inputs in fixed size chunks by passing a "sliding window"
of size n over them. If the input contains less than or equal to
n elements, only one chunk of this size will be emitted.
scala> Stream(1, 2, 3, 4).sliding(2).toList res0: List[Vector[Int]] = List(Vector(1, 2), Vector(2, 3), Vector(3, 4))
scala.IllegalArgumentException if n <= 0
Breaks the input into chunks where the delimiter matches the predicate.
Breaks the input into chunks where the delimiter matches the predicate. The delimiter does not appear in the output. Two adjacent delimiters in the input result in an empty chunk in the output.
Creates a Stepper, which allows incrementally stepping a pure pipe.
Writes the sum of all input elements, or zero if the input is empty.
Emits all elements of the input except the first one.
Emits the first n elements of the input Handle and returns the new Handle.
Emits the last n elements of the input.
Like takeWhile, but emits the first value which tests false.
Emits the longest prefix of the input for which all elements test true according to f.
Filters any 'None'.
Halts the input stream at the first None.
Halts the input stream at the first None.
scala> Stream[Pure, Option[Int]](Some(1), Some(2), None, Some(3), None).unNoneTerminate.toList res0: List[Int] = List(1, 2)
Converts the input to a stream of 1-element chunks.
Groups inputs into separate Vector objects of size n.
Groups inputs into separate Vector objects of size n.
scala> Stream(1, 2, 3, 4, 5).vectorChunkN(2).toVector res0: Vector[Vector[Int]] = Vector(Vector(1, 2), Vector(3, 4), Vector(5))
Zips the elements of the input Handle with its indices, and returns the new Handle
Zips the elements of the input Handle with its next element wrapped into Some, and returns the new Handle.
Zips the elements of the input Handle with its next element wrapped into Some, and returns the new Handle.
The last element is zipped with None.
Zips the elements of the input Handle with its previous element wrapped into Some, and returns the new Handle.
Zips the elements of the input Handle with its previous element wrapped into Some, and returns the new Handle.
The first element is zipped with None.
Zips the elements of the input Handle with its previous and next elements wrapped into Some, and returns the new Handle.
Zips the elements of the input Handle with its previous and next elements wrapped into Some, and returns the new Handle.
The first element is zipped with None as the previous element,
the last element is zipped with None as the next element.
Zips the input with a running total according to S, up to but not including the current element.
Zips the input with a running total according to S, up to but not including the current element. Thus the initial
z value is the first emitted to the output:
scala> Stream("uno", "dos", "tres", "cuatro").zipWithScan(0)(_ + _.length).toList res0: List[(String,Int)] = List((uno,0), (dos,3), (tres,6), (cuatro,10))
Zips the input with a running total according to S, including the current element.
Zips the input with a running total according to S, including the current element. Thus the initial
z value is the first emitted to the output:
scala> Stream("uno", "dos", "tres", "cuatro").zipWithScan1(0)(_ + _.length).toList res0: List[(String, Int)] = List((uno,3), (dos,6), (tres,10), (cuatro,16))
Generic implementations of common pipes.