raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 10

!str #16902: Unify stream internal representation

Browse source 
also =str #16912: Fix StreamTcpSpec flakiness
This commit is contained in:
Endre Sándor Varga 2015-01-28 14:19:50 +01:00
parent cac9c9f2fb
commit 8d77fa8b29
230 changed files with 7814 additions and 9596 deletions
Download patch file Download diff file Expand all files Collapse all files

285
akka-stream/src/main/scala/akka/stream/scaladsl/Flow.scala
View file

@ -3,155 +3,212 @@
*/
package akka.stream.scaladsl
import akka.stream.impl.Ast._
import akka.stream.impl.Stages.{ MaterializingStageFactory, StageModule }
import akka.stream.impl.StreamLayout.{ EmptyModule, Module }
import akka.stream._
import akka.stream.scaladsl.OperationAttributes._
import akka.stream.{ TimerTransformer, TransformerLike, OverflowStrategy }
import akka.util.Collections.EmptyImmutableSeq
import org.reactivestreams.Processor
import scala.annotation.unchecked.uncheckedVariance
import scala.collection.immutable
import scala.concurrent.duration.{ Duration, FiniteDuration }
import scala.concurrent.Future
import scala.language.higherKinds
import akka.stream.FlowMaterializer
import akka.stream.FlattenStrategy
import akka.stream.stage._
import akka.stream.impl.{ Stages, StreamLayout, FlowModule }
/**
* A `Flow` is a set of stream processing steps that has one open input and one open output.
*/
trait Flow[-In, +Out] extends FlowOps[Out] {
override type Repr[+O] <: Flow[In, O]
final class Flow[-In, +Out, +Mat](private[stream] override val module: Module)
extends FlowOps[Out, Mat] with Graph[FlowShape[In, Out], Mat] {
override val shape: FlowShape[In, Out] = module.shape.asInstanceOf[FlowShape[In, Out]]
override type Repr[+O, +M] = Flow[In @uncheckedVariance, O, M]
private[stream] def isIdentity: Boolean = this.module.isInstanceOf[Stages.Identity]
/**
* Transform this [[Flow]] by appending the given processing steps.
*/
def via[T](flow: Flow[Out, T]): Flow[In, T]
def via[T, Mat2](flow: Flow[Out, T, Mat2]): Flow[In, T, Mat] = viaMat(flow)(Keep.left)
/**
* Connect this [[Flow]] to a [[Sink]], concatenating the processing steps of both.
* Transform this [[Flow]] by appending the given processing steps.
*/
def to(sink: Sink[Out]): Sink[In]
/**
* Join this [[Flow]] to another [[Flow]], by cross connecting the inputs and outputs, creating a [[RunnableFlow]]
*/
def join(flow: Flow[Out, In]): RunnableFlow
/**
*
* Connect the `Source` to this `Flow` and then connect it to the `Sink` and run it. The returned tuple contains
* the materialized values of the `Source` and `Sink`, e.g. the `Subscriber` of a [[SubscriberSource]] and
* and `Publisher` of a [[PublisherSink]].
*/
def runWith(source: Source[In], sink: Sink[Out])(implicit materializer: FlowMaterializer): (source.MaterializedType, sink.MaterializedType) = {
val m = source.via(this).to(sink).run()
(m.get(source), m.get(sink))
}
/**
* Returns a new `Flow` that concatenates a secondary `Source` to this flow so that,
* the first element emitted by the given ("second") source is emitted after the last element of this Flow.
*/
def concat(second: Source[In]): Flow[In, Out] = {
Flow() { b ⇒
val concatter = Concat[Out]
val source = UndefinedSource[In]
val sink = UndefinedSink[Out]
b.addEdge(source, this, concatter.first)
.addEdge(second, this, concatter.second)
.addEdge(concatter.out, sink)
source → sink
def viaMat[T, Mat2, Mat3](flow: Flow[Out, T, Mat2])(combine: (Mat, Mat2) ⇒ Mat3): Flow[In, T, Mat3] = {
if (this.isIdentity) flow.asInstanceOf[Flow[In, T, Mat3]]
else {
val flowCopy = flow.module.carbonCopy
new Flow(
module
.growConnect(flowCopy, shape.outlet, flowCopy.shape.inlets.head, combine)
.replaceShape(FlowShape(shape.inlet, flowCopy.shape.outlets.head)))
}
}
/**
* Add a key that will have a value available after materialization.
* The key can only use other keys if they have been added to the flow
* before this key.
* Connect this [[Flow]] to a [[Sink]], concatenating the processing steps of both.
*/
def withKey(key: Key[_]): Flow[In, Out]
def to[Mat2](sink: Sink[Out, Mat2]): Sink[In, Mat] = {
toMat(sink)(Keep.left)
}
/**
* Connect this [[Flow]] to a [[Sink]], concatenating the processing steps of both.
*/
def toMat[Mat2, Mat3](sink: Sink[Out, Mat2])(combine: (Mat, Mat2) ⇒ Mat3): Sink[In, Mat3] = {
if (isIdentity) sink.asInstanceOf[Sink[In, Mat3]]
else {
val sinkCopy = sink.module.carbonCopy
new Sink(
module
.growConnect(sinkCopy, shape.outlet, sinkCopy.shape.inlets.head, combine)
.replaceShape(SinkShape(shape.inlet)))
}
}
/**
* Transform the materialized value of this Flow, leaving all other properties as they were.
*/
def mapMaterialized[Mat2](f: Mat ⇒ Mat2): Repr[Out, Mat2] =
new Flow(module.transformMaterializedValue(f.asInstanceOf[Any ⇒ Any]))
/**
* Join this [[Flow]] to another [[Flow]], by cross connecting the inputs and outputs, creating a [[RunnableFlow]]
*/
def joinMat[Mat2, Mat3](flow: Flow[Out, In, Mat2])(combine: (Mat, Mat2) ⇒ Mat3): RunnableFlow[Mat3] = {
val flowCopy = flow.module.carbonCopy
RunnableFlow(
module
.grow(flowCopy, combine)
.connect(shape.outlet, flowCopy.shape.inlets.head)
.connect(flowCopy.shape.outlets.head, shape.inlet))
}
/**
* Join this [[Flow]] to another [[Flow]], by cross connecting the inputs and outputs, creating a [[RunnableFlow]]
*/
def join[Mat2](flow: Flow[Out, In, Mat2]): RunnableFlow[(Mat, Mat2)] = {
joinMat(flow)(Keep.both)
}
def concat[Out2 >: Out, Mat2](source: Source[Out2, Mat2]): Flow[In, Out2, (Mat, Mat2)] = {
this.viaMat(Flow(source) { implicit builder ⇒
s ⇒
import FlowGraph.Implicits._
val concat = builder.add(Concat[Out2]())
s.outlet ~> concat.in(1)
(concat.in(0), concat.out)
})(Keep.both)
}
/** INTERNAL API */
override private[stream] def andThen[U](op: StageModule): Repr[U, Mat] = {
//No need to copy here, op is a fresh instanc
if (this.isIdentity) new Flow(op).asInstanceOf[Repr[U, Mat]]
else new Flow(module.growConnect(op, shape.outlet, op.inPort).replaceShape(FlowShape(shape.inlet, op.outPort)))
}
private[stream] def andThenMat[U, Mat2](op: MaterializingStageFactory): Repr[U, Mat2] = {
if (this.isIdentity) new Flow(op).asInstanceOf[Repr[U, Mat2]]
else new Flow(module.growConnect(op, shape.outlet, op.inPort, Keep.right).replaceShape(FlowShape(shape.inlet, op.outPort)))
}
private[stream] def andThenMat[U, Mat2, O >: Out](processorFactory: () ⇒ (Processor[O, U], Mat2)): Repr[U, Mat2] = {
val op = Stages.DirectProcessor(processorFactory.asInstanceOf[() ⇒ (Processor[Any, Any], Any)])
if (this.isIdentity) new Flow(op).asInstanceOf[Repr[U, Mat2]]
else new Flow[In, U, Mat2](module.growConnect(op, shape.outlet, op.inPort, Keep.right).replaceShape(FlowShape(shape.inlet, op.outPort)))
}
override def withAttributes(attr: OperationAttributes): Repr[Out, Mat] = {
require(this.module ne EmptyModule, "Cannot set the attributes of empty flow")
new Flow(module.withAttributes(attr).wrap())
}
/**
* Connect the `Source` to this `Flow` and then connect it to the `Sink` and run it. The returned tuple contains
* the materialized values of the `Source` and `Sink`, e.g. the `Subscriber` of a [[SubscriberSource]] and
* and `Publisher` of a [[PublisherSink]].
*/
def runWith[Mat1, Mat2](source: Source[In, Mat1], sink: Sink[Out, Mat2])(implicit materializer: ActorFlowMaterializer): (Mat1, Mat2) = {
source.via(this).toMat(sink)(Keep.both).run()
}
def section[O, O2 >: Out, Mat2, Mat3](attributes: OperationAttributes, combine: (Mat, Mat2) ⇒ Mat3)(section: Flow[O2, O2, Unit] ⇒ Flow[O2, O, Mat2]): Flow[In, O, Mat3] = {
val subFlow = section(Flow[O2]).module.carbonCopy.withAttributes(attributes).wrap()
if (this.isIdentity) new Flow(subFlow).asInstanceOf[Flow[In, O, Mat3]]
else new Flow(
module
.growConnect(subFlow, shape.outlet, subFlow.shape.inlets.head, combine)
.replaceShape(FlowShape(shape.inlet, subFlow.shape.outlets.head)))
}
/**
* Applies given [[OperationAttributes]] to a given section.
*/
def section[I <: In, O](attributes: OperationAttributes)(section: Flow[In, Out] ⇒ Flow[I, O]): Flow[I, O] =
section(this.withAttributes(attributes)).withAttributes(OperationAttributes.none)
def section[O, O2 >: Out, Mat2](attributes: OperationAttributes)(section: Flow[O2, O2, Unit] ⇒ Flow[O2, O, Mat2]): Flow[In, O, Mat2] = {
this.section[O, O2, Mat2, Mat2](attributes, Keep.right)(section)
}
}
object Flow {
/**
* Creates an empty `Flow` of type `T`
*/
def empty[T]: Flow[T, T] = Pipe.empty[T]
object Flow extends FlowApply {
private def shape[I, O](name: String): FlowShape[I, O] = FlowShape(new Inlet(name + ".in"), new Outlet(name + ".out"))
/**
* Helper to create `Flow` without a [[Source]] or a [[Sink]].
* Example usage: `Flow[Int]`
*/
def apply[T]: Flow[T, T] = Pipe.empty[T]
def apply[T]: Flow[T, T, Unit] = new Flow[Any, Any, Any](Stages.Identity()).asInstanceOf[Flow[T, T, Unit]]
/**
* Creates a `Flow` by using an empty [[FlowGraphBuilder]] on a block that expects a [[FlowGraphBuilder]] and
* returns the `UndefinedSource` and `UndefinedSink`.
* A graph with the shape of a source logically is a source, this method makes
* it so also in type.
*/
def apply[I, O]()(block: FlowGraphBuilder ⇒ (UndefinedSource[I], UndefinedSink[O])): Flow[I, O] =
createFlowFromBuilder(new FlowGraphBuilder(), block)
def wrap[I, O, M](g: Graph[FlowShape[I, O], M]): Flow[I, O, M] = new Flow(g.module)
/**
* Creates a `Flow` by using a [[FlowGraphBuilder]] from this [[PartialFlowGraph]] on a block that expects
* a [[FlowGraphBuilder]] and returns the `UndefinedSource` and `UndefinedSink`.
*/
def apply[I, O](graph: PartialFlowGraph)(block: FlowGraphBuilder ⇒ (UndefinedSource[I], UndefinedSink[O])): Flow[I, O] =
createFlowFromBuilder(new FlowGraphBuilder(graph), block)
private def createFlowFromBuilder[I, O](builder: FlowGraphBuilder,
block: FlowGraphBuilder ⇒ (UndefinedSource[I], UndefinedSink[O])): Flow[I, O] = {
val (in, out) = block(builder)
builder.partialBuild().toFlow(in, out)
}
/**
* Create a [[Flow]] from a seemingly disconnected [[Source]] and [[Sink]] pair.
*/
def apply[I, O](sink: Sink[I], source: Source[O]): Flow[I, O] = GraphBackedFlow(sink, source)
}
/**
* Flow with attached input and output, can be executed.
*/
trait RunnableFlow {
/**
* Run this flow and return the [[MaterializedMap]] containing the values for the [[KeyedMaterializable]] of the flow.
*/
def run()(implicit materializer: FlowMaterializer): MaterializedMap
case class RunnableFlow[+Mat](private[stream] val module: StreamLayout.Module) {
assert(module.isRunnable)
/**
* Run this flow and return the value of the [[KeyedMaterializable]].
* Transform only the materialized value of this RunnableFlow, leaving all other properties as they were.
*/
def runWith(key: KeyedMaterializable[_])(implicit materializer: FlowMaterializer): key.MaterializedType =
this.run().get(key)
def mapMaterialized[Mat2](f: Mat ⇒ Mat2): RunnableFlow[Mat2] =
copy(module.transformMaterializedValue(f.asInstanceOf[Any ⇒ Any]))
/**
* Run this flow and return the materialized instance from the flow.
*/
def run()(implicit materializer: ActorFlowMaterializer): Mat = materializer.materialize(this)
}
/**
* Scala API: Operations offered by Sources and Flows with a free output side: the DSL flows left-to-right only.
*/
trait FlowOps[+Out] {
trait FlowOps[+Out, +Mat] {
import akka.stream.impl.Stages._
import FlowOps._
type Repr[+O] <: FlowOps[O]
type Repr[+O, +M] <: FlowOps[O, M]
/**
* Transform this stream by applying the given function to each of the elements
* as they pass through this processing step.
*/
def map[T](f: Out ⇒ T): Repr[T] = andThen(Map(f.asInstanceOf[Any ⇒ Any]))
def map[T](f: Out ⇒ T): Repr[T, Mat] = andThen(Map(f.asInstanceOf[Any ⇒ Any]))
/**
* Transform each input element into a sequence of output elements that is
* then flattened into the output stream.
*/
def mapConcat[T](f: Out ⇒ immutable.Seq[T]): Repr[T] = andThen(MapConcat(f.asInstanceOf[Any ⇒ immutable.Seq[Any]]))
def mapConcat[T](f: Out ⇒ immutable.Seq[T]): Repr[T, Mat] = andThen(MapConcat(f.asInstanceOf[Any ⇒ immutable.Seq[Any]]))
/**
* Transform this stream by applying the given function to each of the elements
@ -170,7 +227,7 @@ trait FlowOps[+Out] {
*
* @see [[#mapAsyncUnordered]]
*/
def mapAsync[T](f: Out ⇒ Future[T]): Repr[T] =
def mapAsync[T](f: Out ⇒ Future[T]): Repr[T, Mat] =
andThen(MapAsync(f.asInstanceOf[Any ⇒ Future[Any]]))
/**
@ -191,20 +248,20 @@ trait FlowOps[+Out] {
*
* @see [[#mapAsync]]
*/
def mapAsyncUnordered[T](f: Out ⇒ Future[T]): Repr[T] =
def mapAsyncUnordered[T](f: Out ⇒ Future[T]): Repr[T, Mat] =
andThen(MapAsyncUnordered(f.asInstanceOf[Any ⇒ Future[Any]]))
/**
* Only pass on those elements that satisfy the given predicate.
*/
def filter(p: Out ⇒ Boolean): Repr[Out] = andThen(Filter(p.asInstanceOf[Any ⇒ Boolean]))
def filter(p: Out ⇒ Boolean): Repr[Out, Mat] = andThen(Filter(p.asInstanceOf[Any ⇒ Boolean]))
/**
* Transform this stream by applying the given partial function to each of the elements
* on which the function is defined as they pass through this processing step.
* Non-matching elements are filtered out.
*/
def collect[T](pf: PartialFunction[Out, T]): Repr[T] = andThen(Collect(pf.asInstanceOf[PartialFunction[Any, Any]]))
def collect[T](pf: PartialFunction[Out, T]): Repr[T, Mat] = andThen(Collect(pf.asInstanceOf[PartialFunction[Any, Any]]))
/**
* Chunk up this stream into groups of the given size, with the last group
@ -212,7 +269,7 @@ trait FlowOps[+Out] {
*
* `n` must be positive, otherwise IllegalArgumentException is thrown.
*/
def grouped(n: Int): Repr[immutable.Seq[Out]] = andThen(Grouped(n))
def grouped(n: Int): Repr[immutable.Seq[Out], Mat] = andThen(Grouped(n))
/**
* Similar to `fold` but is not a terminal operation,
@ -224,7 +281,7 @@ trait FlowOps[+Out] {
* [[akka.stream.Supervision.Restart]] current value starts at `zero` again
* the stream will continue.
*/
def scan[T](zero: T)(f: (T, Out) ⇒ T): Repr[T] = andThen(Scan(zero, f.asInstanceOf[(Any, Any) ⇒ Any]))
def scan[T](zero: T)(f: (T, Out) ⇒ T): Repr[T, Mat] = andThen(Scan(zero, f.asInstanceOf[(Any, Any) ⇒ Any]))
/**
* Chunk up this stream into groups of elements received within a time window,
@ -236,7 +293,7 @@ trait FlowOps[+Out] {
* `n` must be positive, and `d` must be greater than 0 seconds, otherwise
* IllegalArgumentException is thrown.
*/
def groupedWithin(n: Int, d: FiniteDuration): Repr[Out]#Repr[immutable.Seq[Out]] = {
def groupedWithin(n: Int, d: FiniteDuration): Repr[Out, Mat]#Repr[immutable.Seq[Out], Mat] = {
require(n > 0, "n must be greater than 0")
require(d > Duration.Zero)
withAttributes(name("groupedWithin")).timerTransform(() ⇒ new TimerTransformer[Out, immutable.Seq[Out]] {
@ -267,12 +324,12 @@ trait FlowOps[+Out] {
* Discard the given number of elements at the beginning of the stream.
* No elements will be dropped if `n` is zero or negative.
*/
def drop(n: Int): Repr[Out] = andThen(Drop(n))
def drop(n: Int): Repr[Out, Mat] = andThen(Drop(n))
/**
* Discard the elements received within the given duration at beginning of the stream.
*/
def dropWithin(d: FiniteDuration): Repr[Out]#Repr[Out] =
def dropWithin(d: FiniteDuration): Repr[Out, Mat]#Repr[Out, Mat] =
withAttributes(name("dropWithin")).timerTransform(() ⇒ new TimerTransformer[Out, Out] {
scheduleOnce(DropWithinTimerKey, d)
@ -297,7 +354,7 @@ trait FlowOps[+Out] {
* The stream will be completed without producing any elements if `n` is zero
* or negative.
*/
def take(n: Int): Repr[Out] = andThen(Take(n))
def take(n: Int): Repr[Out, Mat] = andThen(Take(n))
/**
* Terminate processing (and cancel the upstream publisher) after the given
@ -308,7 +365,7 @@ trait FlowOps[+Out] {
* Note that this can be combined with [[#take]] to limit the number of elements
* within the duration.
*/
def takeWithin(d: FiniteDuration): Repr[Out]#Repr[Out] =
def takeWithin(d: FiniteDuration): Repr[Out, Mat]#Repr[Out, Mat] =
withAttributes(name("takeWithin")).timerTransform(() ⇒ new TimerTransformer[Out, Out] {
scheduleOnce(TakeWithinTimerKey, d)
@ -333,7 +390,7 @@ trait FlowOps[+Out] {
* @param seed Provides the first state for a conflated value using the first unconsumed element as a start
* @param aggregate Takes the currently aggregated value and the current pending element to produce a new aggregate
*/
def conflate[S](seed: Out ⇒ S)(aggregate: (S, Out) ⇒ S): Repr[S] =
def conflate[S](seed: Out ⇒ S)(aggregate: (S, Out) ⇒ S): Repr[S, Mat] =
andThen(Conflate(seed.asInstanceOf[Any ⇒ Any], aggregate.asInstanceOf[(Any, Any) ⇒ Any]))
/**
@ -352,7 +409,7 @@ trait FlowOps[+Out] {
* @param extrapolate Takes the current extrapolation state to produce an output element and the next extrapolation
* state.
*/
def expand[S, U](seed: Out ⇒ S)(extrapolate: S ⇒ (U, S)): Repr[U] =
def expand[S, U](seed: Out ⇒ S)(extrapolate: S ⇒ (U, S)): Repr[U, Mat] =
andThen(Expand(seed.asInstanceOf[Any ⇒ Any], extrapolate.asInstanceOf[Any ⇒ (Any, Any)]))
/**
@ -363,7 +420,7 @@ trait FlowOps[+Out] {
* @param size The size of the buffer in element count
* @param overflowStrategy Strategy that is used when incoming elements cannot fit inside the buffer
*/
def buffer(size: Int, overflowStrategy: OverflowStrategy): Repr[Out] =
def buffer(size: Int, overflowStrategy: OverflowStrategy): Repr[Out, Mat] =
andThen(Buffer(size, overflowStrategy))
/**
@ -371,15 +428,18 @@ trait FlowOps[+Out] {
* This operator makes it possible to extend the `Flow` API when there is no specialized
* operator that performs the transformation.
*/
def transform[T](mkStage: () ⇒ Stage[Out, T]): Repr[T] =
def transform[T](mkStage: () ⇒ Stage[Out, T]): Repr[T, Mat] =
andThen(StageFactory(mkStage))
private[akka] def transformMaterializing[T, M](mkStageAndMaterialized: () ⇒ (Stage[Out, T], M)): Repr[T, M] =
andThenMat(MaterializingStageFactory(mkStageAndMaterialized))
/**
* Takes up to `n` elements from the stream and returns a pair containing a strict sequence of the taken element
* and a stream representing the remaining elements. If ''n'' is zero or negative, then this will return a pair
* of an empty collection and a stream containing the whole upstream unchanged.
*/
def prefixAndTail[U >: Out](n: Int): Repr[(immutable.Seq[Out], Source[U])] =
def prefixAndTail[U >: Out](n: Int): Repr[(immutable.Seq[Out], Source[U, Unit]), Mat] =
andThen(PrefixAndTail(n))
/**
@ -401,7 +461,7 @@ trait FlowOps[+Out] {
* is [[akka.stream.Supervision.Resume]] or [[akka.stream.Supervision.Restart]]
* the element is dropped and the stream and substreams continue.
*/
def groupBy[K, U >: Out](f: Out ⇒ K): Repr[(K, Source[U])] =
def groupBy[K, U >: Out](f: Out ⇒ K): Repr[(K, Source[U, Unit]), Mat] =
andThen(GroupBy(f.asInstanceOf[Any ⇒ Any]))
/**
@ -425,14 +485,14 @@ trait FlowOps[+Out] {
* is [[akka.stream.Supervision.Resume]] or [[akka.stream.Supervision.Restart]]
* the element is dropped and the stream and substreams continue.
*/
def splitWhen[U >: Out](p: Out ⇒ Boolean): Repr[Source[U]] =
def splitWhen[U >: Out](p: Out ⇒ Boolean): Repr[Source[U, Unit], Mat] =
andThen(SplitWhen(p.asInstanceOf[Any ⇒ Boolean]))
/**
* Transforms a stream of streams into a contiguous stream of elements using the provided flattening strategy.
* This operation can be used on a stream of element type [[akka.stream.scaladsl.Source]].
*/
def flatten[U](strategy: akka.stream.FlattenStrategy[Out, U]): Repr[U] = strategy match {
def flatten[U](strategy: akka.stream.FlattenStrategy[Out, U]): Repr[U, Mat] = strategy match {
case _: FlattenStrategy.Concat[Out] ⇒ andThen(ConcatAll())
case _ ⇒
throw new IllegalArgumentException(s"Unsupported flattening strategy [${strategy.getClass.getName}]")
@ -464,15 +524,15 @@ trait FlowOps[+Out] {
*
* Note that you can use [[#transform]] if you just need to transform elements time plays no role in the transformation.
*/
private[akka] def timerTransform[U](mkStage: () ⇒ TimerTransformer[Out, U]): Repr[U] =
private[akka] def timerTransform[U](mkStage: () ⇒ TimerTransformer[Out, U]): Repr[U, Mat] =
andThen(TimerTransform(mkStage.asInstanceOf[() ⇒ TimerTransformer[Any, Any]]))
/** INTERNAL API */
private[scaladsl] def withAttributes(attr: OperationAttributes): Repr[Out]
def withAttributes(attr: OperationAttributes): Repr[Out, Mat]
/** INTERNAL API */
// Storing ops in reverse order
private[scaladsl] def andThen[U](op: AstNode): Repr[U]
private[scaladsl] def andThen[U](op: StageModule): Repr[U, Mat]
private[scaladsl] def andThenMat[U, Mat2](op: MaterializingStageFactory): Repr[U, Mat2]
}
/**
@ -495,7 +555,4 @@ private[stream] object FlowOps {
def completedTransformer[T]: TransformerLike[T, T] = CompletedTransformer.asInstanceOf[TransformerLike[T, T]]
def identityTransformer[T]: TransformerLike[T, T] = IdentityTransformer.asInstanceOf[TransformerLike[T, T]]
def identityStage[T]: Stage[T, T] = new PushStage[T, T] {
override def onPush(elem: T, ctx: Context[T]): Directive = ctx.push(elem)
}
}
}